diff --git a/README.md b/README.md
index e21def02..742ff106 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 
 _LMS_ is a self-hosted music streaming software: access your music collection from anywhere using a web interface!
 
-A [demo instance](http://lms-demo.poupon.dev) is available. Note the administration panel is not available.
+A [demo instance](http://lms-demo.poupon.dev) is available. Note the administration settings are not available.
 
 ## Main features
 * Recommendation engine
@@ -34,12 +34,14 @@ _LMS_ provides several ways to help you find the music you like:
   * Starred _Jazz_ albums
   * ...
 
+__Note__: depending on your database size and/or your hardware, the tag-based recommendation engine may significantly slow down the user interface. You can disable it in the administration settings.
+
 ## About tags
 _LMS_ relies exclusively on tags to organize your music collection.
 
 ### Filtering
 You can specify the tags you want to use to filter your collection. By default, `genre`, `albumgrouping`, `mood` and `albummood` tags are used.
-In the administration  panel, you can set whatever tags you want, even custom tags.
+In the administration settings, you can set whatever tags you want, even custom tags.
 
 __Note__: you can use the `lms-metadata` tool to have an idea of the tags parsed by _LMS_ using [TagLib](https://github.com/taglib/taglib).
 
diff --git a/approot/admin-database.xml b/approot/admin-database.xml
index df1f883e..dcd81c0f 100644
--- a/approot/admin-database.xml
+++ b/approot/admin-database.xml
@@ -34,17 +34,15 @@
 			</div>
 		</div>
 		<legend>${tr:Lms.Admin.Database.scan-options}</legend>
-		${<if-has-recommendation-engine>}
-		<div class="col-lg-6">
-			<label class="form-label" for="${id:recommendation-engine-type}">
-				${tr:Lms.Admin.Database.recommendation-engine-type}
+		<div class="col-12">
+			<label class="form-label" for="${id:similarity-engine-type}">
+				${tr:Lms.Admin.Database.similarity-engine-type}
 			</label>
-			${recommendation-engine-type class="form-control"}
+			${similarity-engine-type class="form-control"}
 			<div class="invalid-feedback">
-				${recommendation-engine-type-info}
+				${similarity-engine-type-info}
 			</div>
 		</div>
-		${</if-has-recommendation-engine>}
 		<div class="col-12">
 			<label class="form-label" for="${id:clusters}">
 				${tr:Lms.clusters}
diff --git a/approot/messages.xml b/approot/messages.xml
index 28883d34..cdaba83b 100644
--- a/approot/messages.xml
+++ b/approot/messages.xml
@@ -53,13 +53,13 @@
 <message id="Lms.Admin.Database.never">Never</message>
 <message id="Lms.Admin.Database.path">Media root directory</message>
 <message id="Lms.Admin.Database.path-help">Directories containing a <code>.lmsignore</code> file are skipped</message>
-<message id="Lms.Admin.Database.recommendation-engine-type">Recommendation engine</message>
-<message id="Lms.Admin.Database.recommendation-engine-type.clusters">Tags based</message>
-<message id="Lms.Admin.Database.recommendation-engine-type.features">Audio analysis based</message>
 <message id="Lms.Admin.Database.scan-complete">Scan complete: {1} total files, {2} additions, {3} updates, {4} deletions, {5} duplicates, {6} errors</message>
 <message id="Lms.Admin.Database.scan-launched">Scan launched!</message>
 <message id="Lms.Admin.Database.scan-options">Scan options</message>
 <message id="Lms.Admin.Database.settings-saved">New settings saved!</message>
+<message id="Lms.Admin.Database.similarity-engine-type">Similarity engine</message>
+<message id="Lms.Admin.Database.similarity-engine-type.clusters">Tag-based</message>
+<message id="Lms.Admin.Database.similarity-engine-type.none">None</message>
 <message id="Lms.Admin.Database.update-period">Update period</message>
 <message id="Lms.Admin.Database.update-start-time">Update start time</message>
 <message id="Lms.Admin.Database.weekly">Weekly</message>
@@ -240,10 +240,14 @@
 <!--Settings-->
 <message id="Lms.Settings.audio">Audio</message>
 <message id="Lms.Settings.audio-settings-are-local">These audio settings are local to your browser!</message>
+<message id="Lms.Settings.backend.internal">Internal</message>
+<message id="Lms.Settings.backend.listenbrainz">ListenBrainz</message>
+<message id="Lms.Settings.backend.listenbrainz-token">ListenBrainz API token</message>
 <message id="Lms.Settings.change-password">Change password</message>
 <message id="Lms.Settings.default-transcode-bitrate">Default transcode bitrate</message>
 <message id="Lms.Settings.default-transcode-format">Default transcode format</message>
 <message id="Lms.Settings.demo-cannot-save">Cannot save using a demo account!</message>
+<message id="Lms.Settings.feedback">Feedback</message>
 <message id="Lms.Settings.menu-settings"><i class="fa fa-fw fa-cog" aria-hidden="true"></i> Settings</message>
 <message id="Lms.Settings.password-bad">Bad password</message>
 <message id="Lms.Settings.password-must-fill-old-password">Old password must be filled in</message>
@@ -255,10 +259,7 @@
 <message id="Lms.Settings.replaygain-preamp">ReplayGain preamp</message>
 <message id="Lms.Settings.replaygain-preamp-no-rg-info">ReplayGain preamp (if no info)</message>
 <message id="Lms.Settings.scrobbling">Scrobbling</message>
-<message id="Lms.Settings.scrobbling.scrobbler">Scrobbler</message>
-<message id="Lms.Settings.scrobbling.scrobbler.internal">Internal</message>
-<message id="Lms.Settings.scrobbling.scrobbler.listenbrainz">ListenBrainz</message>
-<message id="Lms.Settings.scrobbling.listenbrainz-token">ListenBrainz token</message>
+<message id="Lms.Settings.services">Services</message>
 <message id="Lms.Settings.settings">Settings</message>
 <message id="Lms.Settings.subsonic-artist-list-mode">Artist list mode</message>
 <message id="Lms.Settings.subsonic-artist-list-mode.all-artists">All artists</message>
diff --git a/approot/messages_fr.xml b/approot/messages_fr.xml
index a5f2e255..c67ab668 100644
--- a/approot/messages_fr.xml
+++ b/approot/messages_fr.xml
@@ -53,13 +53,13 @@
 <message id="Lms.Admin.Database.never">Jamais</message>
 <message id="Lms.Admin.Database.path">Dossier racine des fichiers de musique</message>
 <message id="Lms.Admin.Database.path-help">Les dossiers contenant un fichier <code>.lmsignore</code> sont ignorés</message>
-<message id="Lms.Admin.Database.recommendation-engine-type">Moteur de recommandation</message>
-<message id="Lms.Admin.Database.recommendation-engine-type.clusters">Basé sur les tags</message>
-<message id="Lms.Admin.Database.recommendation-engine-type.features">Basé sur l'analyse audio</message>
 <message id="Lms.Admin.Database.scan-complete">Scan terminé : {1} fichiers, {2} ajouts, {3} mises à jour, {4} suppressions, {5} duplicatas, {6} erreurs</message>
 <message id="Lms.Admin.Database.scan-launched">Scan lancé !</message>
 <message id="Lms.Admin.Database.scan-options">Options </message>
 <message id="Lms.Admin.Database.settings-saved">Nouveaux paramètres sauvegardés !</message>
+<message id="Lms.Admin.Database.similarity-engine-type">Moteur de similarité</message>
+<message id="Lms.Admin.Database.similarity-engine-type.clusters">Basé sur les tags</message>
+<message id="Lms.Admin.Database.similarity-engine-type.none">Aucun</message>
 <message id="Lms.Admin.Database.update-period">Périodicité des mises à jour</message>
 <message id="Lms.Admin.Database.update-start-time">Heure de départ de la mise à jour</message>
 <message id="Lms.Admin.Database.weekly">Toutes les semaines</message>
@@ -240,10 +240,14 @@
 <!--Settings-->
 <message id="Lms.Settings.audio">Audio</message>
 <message id="Lms.Settings.audio-settings-are-local">Ces paramètres audio sont locaux à votre navigateur !</message>
+<message id="Lms.Settings.backend.internal">Interne</message>
+<message id="Lms.Settings.backend.listenbrainz">ListenBrainz</message>
+<message id="Lms.Settings.backend.listenbrainz-token">Jeton d'API ListenBrainz</message>
 <message id="Lms.Settings.change-password">Changement de mot de passe</message>
 <message id="Lms.Settings.default-transcode-bitrate">Bitrate par defaut du transcodage</message>
 <message id="Lms.Settings.default-transcode-format">Format par defaut du transcodage</message>
 <message id="Lms.Settings.demo-cannot-save">Impossible de sauvegarder en utilisant un compte de démo !</message>
+<message id="Lms.Settings.feedback">Feedback</message>
 <message id="Lms.Settings.menu-settings"><i class="fa fa-fw fa-cog" aria-hidden="true"></i> Paramètres</message>
 <message id="Lms.Settings.password-bad">Mauvais mot de passe</message>
 <message id="Lms.Settings.password-must-fill-old-password">L'ancien mot de passe doit être renseigné</message>
@@ -255,10 +259,7 @@
 <message id="Lms.Settings.replaygain-preamp">Pre-amplification ReplayGain</message>
 <message id="Lms.Settings.replaygain-preamp-no-rg-info">Pre-amplification ReplayGain (si pas d'info)</message>
 <message id="Lms.Settings.scrobbling">Scrobbling</message>
-<message id="Lms.Settings.scrobbling.scrobbler">Scrobbler</message>
-<message id="Lms.Settings.scrobbling.scrobbler.internal">Interne</message>
-<message id="Lms.Settings.scrobbling.scrobbler.listenbrainz">ListenBrainz</message>
-<message id="Lms.Settings.scrobbling.listenbrainz-token">Jeton ListenBrainz</message>
+<message id="Lms.Settings.services">Services</message>
 <message id="Lms.Settings.settings">Paramètres</message>
 <message id="Lms.Settings.subsonic-artist-list-mode">Mode de listage des artistes</message>
 <message id="Lms.Settings.subsonic-artist-list-mode.all-artists">Tous les artistes</message>
diff --git a/approot/messages_it.xml b/approot/messages_it.xml
index 7849ef42..518fc9b6 100644
--- a/approot/messages_it.xml
+++ b/approot/messages_it.xml
@@ -9,7 +9,7 @@
 <message id="Lms.cancel">Annulla</message>
 <message id="Lms.clusters">Tags</message>
 <message id="Lms.create">Crea</message>
-<message id="Lms.del">Elimina</message>
+<message id="Lms.delete">Elimina</message>
 <message id="Lms.discard">Annulla</message>
 <message id="Lms.edit">Modifica</message>
 <message id="Lms.loading">Caricamento...</message>
@@ -53,13 +53,13 @@
 <message id="Lms.Admin.Database.never">Mai</message>
 <message id="Lms.Admin.Database.path">Cartella dei file multimediali</message>
 
-<message id="Lms.Admin.Database.recommendation-engine-type">Modalità di raccomandazione brani consigliati</message>
-<message id="Lms.Admin.Database.recommendation-engine-type.clusters">Basata sui tag</message>
-<message id="Lms.Admin.Database.recommendation-engine-type.features">Basata sull'analisi acustica</message>
 <message id="Lms.Admin.Database.scan-complete">Scansione completata: {1} file totali, {2} aggiunti, {3} aggiornati, {4} eliminati, {5} duplicati, {6} errati</message>
 <message id="Lms.Admin.Database.scan-launched">Scansione avviata!</message>
 <message id="Lms.Admin.Database.scan-options">Impostazioni scansione</message>
 <message id="Lms.Admin.Database.settings-saved">Impostazioni salvate!</message>
+
+
+
 <message id="Lms.Admin.Database.update-period">Frequenza di aggiornamento</message>
 <message id="Lms.Admin.Database.update-start-time">Orario di aggiornamento</message>
 <message id="Lms.Admin.Database.weekly">Settimanale</message>
@@ -240,10 +240,14 @@
 <!--Settings-->
 <message id="Lms.Settings.audio">Audio</message>
 <message id="Lms.Settings.audio-settings-are-local">Queste impostazioni sono salvate localmente su questo dispositivo!</message>
+
+
+
 <message id="Lms.Settings.change-password">Cambia password</message>
 
 
 <message id="Lms.Settings.demo-cannot-save">Non posso salvare le impostazioni utilizzando l'account demo!</message>
+
 <message id="Lms.Settings.menu-settings"><i class="fa fa-fw fa-cog" aria-hidden="true"></i> Impostazioni</message>
 <message id="Lms.Settings.password-bad">Password errata</message>
 <message id="Lms.Settings.password-must-fill-old-password">Devi inserire la password attuale</message>
@@ -257,9 +261,6 @@
 
 
 
-
-
-
 <message id="Lms.Settings.subsonic-artist-list-mode">Modalità di elencazione artisti</message>
 <message id="Lms.Settings.subsonic-artist-list-mode.all-artists">Tutti gli artisti</message>
 <message id="Lms.Settings.subsonic-artist-list-mode.release-artists">Artisti album</message>
diff --git a/approot/messages_zh.xml b/approot/messages_zh.xml
index c1eca28c..9442202c 100644
--- a/approot/messages_zh.xml
+++ b/approot/messages_zh.xml
@@ -53,13 +53,13 @@
 <message id="Lms.Admin.Database.never">从不</message>
 <message id="Lms.Admin.Database.path">媒体根目录</message>
 <message id="Lms.Admin.Database.path-help">包含 <code>.lmsignore</code> 文件的目录将会被跳过</message>
-<message id="Lms.Admin.Database.recommendation-engine-type">推荐引擎</message>
-<message id="Lms.Admin.Database.recommendation-engine-type.clusters">基于标签</message>
-<message id="Lms.Admin.Database.recommendation-engine-type.features">基于音频分析</message>
 <message id="Lms.Admin.Database.scan-complete">扫描完成：总文件 {1}，添加文件 {2}，更新文件 {3}，删除文件 {4}，重复文件 {5}，错误文件 {6}</message>
 <message id="Lms.Admin.Database.scan-launched">扫描已完成！</message>
 <message id="Lms.Admin.Database.scan-options">扫描选项</message>
 <message id="Lms.Admin.Database.settings-saved">新设置已保存！</message>
+
+
+
 <message id="Lms.Admin.Database.update-period">更新周期</message>
 <message id="Lms.Admin.Database.update-start-time">更新开始时间</message>
 <message id="Lms.Admin.Database.weekly">每周</message>
@@ -240,10 +240,14 @@
 <!--Settings-->
 <message id="Lms.Settings.audio">音频</message>
 <message id="Lms.Settings.audio-settings-are-local">这些音频设置仅保存在您的本地浏览器！</message>
+
+
+
 <message id="Lms.Settings.change-password">更改密码</message>
 
 
 <message id="Lms.Settings.demo-cannot-save">使用演示账号时不能保存！</message>
+
 <message id="Lms.Settings.menu-settings"><i class="fa fa-fw fa-cog" aria-hidden="true"></i> 设置</message>
 <message id="Lms.Settings.password-bad">无效密码</message>
 <message id="Lms.Settings.password-must-fill-old-password">必须填写旧密码</message>
@@ -257,9 +261,6 @@
 
 
 
-
-
-
 <message id="Lms.Settings.subsonic-artist-list-mode">歌手列表模式</message>
 <message id="Lms.Settings.subsonic-artist-list-mode.all-artists">所有歌手</message>
 <message id="Lms.Settings.subsonic-artist-list-mode.release-artists">专辑歌手</message>
diff --git a/approot/search.xml b/approot/search.xml
index 4f248d70..cb417139 100644
--- a/approot/search.xml
+++ b/approot/search.xml
@@ -3,29 +3,29 @@
 <!--FORMS message blocks-->
 
 <message id="Lms.Explore.Search.template">
-	<ul class="nav nav-pills mb-3" id="myTab" role="tablist">
-		<li class="nav-item" role="presentation">
-			<button class="nav-link active" id="releases-tab" data-bs-toggle="tab" data-bs-target="#releases" type="button" role="tab" aria-controls="releases" aria-selected="true">${tr:Lms.Explore.releases}</button>
-		</li>
-		<li class="nav-item" role="presentation">
-			<button class="nav-link" id="artists-tab" data-bs-toggle="tab" data-bs-target="#artists" type="button" role="tab" aria-controls="artists" aria-selected="false">${tr:Lms.Explore.artists}</button>
-		</li>
-		<li class="nav-item" role="presentation">
-			<button class="nav-link" id="tracks-tab" data-bs-toggle="tab" data-bs-target="#tracks" type="button" role="tab" aria-controls="tracks" aria-selected="false">${tr:Lms.Explore.tracks}</button>
-		</li>
-	</ul>
-	<div class="tab-content" id="myTabContent">
-		<div class="tab-pane show active" id="releases" role="tabpanel" aria-labelledby="releases-tab">${releases}</div>
-		<div class="tab-pane" id="artists" role="tabpanel" aria-labelledby="artists-tab">
-			<div class="row mb-3">
-				<div class="col-lg-3">
-					${link-type class="form-select"}
-				</div>
-			</div>
-			${artists}
-		</div>
-		<div class="tab-pane" id="tracks" role="tabpanel" aria-labelledby="tracks-tab">${tracks}</div>
+	<div class="mb-3">
+		<ul class="nav nav-pills mb-3">
+			<li class="nav-item">
+				${releases class="nav-link"}
+			</li>
+			<li class="nav-item">
+				${artists class="nav-link"}
+			</li>
+			<li class="nav-item">
+				${tracks class="nav-link"}
+			</li>
+		</ul>
 	</div>
+	${results}
+</message>
+
+<message id="Lms.Explore.Search.template.artists">
+	<div class="row mb-3">
+		<div class="col-lg-3">
+			${link-type class="form-select"}
+		</div>
+	</div>
+	${artists}
 </message>
 
 </messages>
diff --git a/approot/settings.xml b/approot/settings.xml
index c15db564..507ec686 100644
--- a/approot/settings.xml
+++ b/approot/settings.xml
@@ -28,9 +28,9 @@
 			</div>
 		</div>
 		<div class="col-lg-4">
-			<label class="form-label"  for="${id:transcode-bitrate}">
+			<label class="form-label" for="${id:transcode-bitrate}">
 				${tr:Lms.Settings.transcode-bitrate}
-;			</label>
+			</label>
 			<div class="input-group mb-3">
 				${transcode-bitrate class="form-control"}
 				<span class="input-group-text">kbps</span>
@@ -105,19 +105,28 @@
 				</div>
 			</div>
 			${</if-has-subsonic-api>}
-		<legend>${tr:Lms.Settings.scrobbling}</legend>
+		<legend>${tr:Lms.Settings.services}</legend>
 		<div class="col-lg-6">
-			<label class="form-label" for="${id:scrobbler}">
-				${tr:Lms.Settings.scrobbling.scrobbler}
+			<label class="form-label" for="${id:scrobbling-backend}">
+				${tr:Lms.Settings.scrobbling}
 			</label>
-			${scrobbler class="form-control"}
+			${scrobbling-backend class="form-control"}
 			<div class="invalid-feedback">
-				${scrobbler-info class="help-block"}
+				${scrobbling-backend-info class="help-block"}
 			</div>
 		</div>
 		<div class="col-lg-6">
+			<label class="form-label" for="${id:feedback-backend}">
+				${tr:Lms.Settings.feedback}
+			</label>
+			${feedback-backend class="form-control"}
+			<div class="invalid-feedback">
+				${feedback-backend-info class="help-block"}
+			</div>
+		</div>
+		<div class="col-lg-12">
 			<label class="form-label" for="${id:listenbrainz-token}">
-				${tr:Lms.Settings.scrobbling.listenbrainz-token}
+				${tr:Lms.Settings.backend.listenbrainz-token}
 			</label>
 			${listenbrainz-token class="form-control"}
 			<div class="invalid-feedback">
diff --git a/conf/lms.conf b/conf/lms.conf
index 4454eff4..07e7943f 100644
--- a/conf/lms.conf
+++ b/conf/lms.conf
@@ -63,6 +63,9 @@ api-subsonic = true;
 # Main usage is to make auto detections for the 'p' (password) parameter work
 api-subsonic-report-old-server-protocol = ("DSub");
 
+# List of clients for whom open subsonic extensions and extra fields are disabled
+api-open-subsonic-disabled-clients = ("DSub");
+
 # Turn on this option to allow the demo account creation/use
 demo = false;
 
@@ -85,4 +88,4 @@ playqueue-max-entry-count = 1000;
 scanner-skip-duplicate-mbid = false;
 
 # Scanner read style for metadata, maybe be 'fast', 'average' or 'accurate'
-scanner-parser-read-style = "accurate";
+scanner-parser-read-style = "average";
diff --git a/src/libs/av/impl/TranscodeResourceHandler.cpp b/src/libs/av/impl/TranscodeResourceHandler.cpp
index 6535f806..753213c4 100644
--- a/src/libs/av/impl/TranscodeResourceHandler.cpp
+++ b/src/libs/av/impl/TranscodeResourceHandler.cpp
@@ -56,10 +56,12 @@ namespace Av
 		if (_estimatedContentLength)
 			response.setContentLength(*_estimatedContentLength);
 		response.setMimeType(_transcoder.getOutputMimeType());
-		LMS_LOG(TRANSCODE, DEBUG) << "Set mime type to " << _transcoder.getOutputMimeType();
+		LMS_LOG(TRANSCODE, DEBUG) << "Transcoder finished = " << _transcoder.finished() << ", total served bytes = " << _totalServedByteCount << ", mime type = " << _transcoder.getOutputMimeType();
 
 		if (_bytesReadyCount > 0)
 		{
+			LMS_LOG(TRANSCODE, DEBUG) << "Writing " << _bytesReadyCount << " bytes back to client";
+
 			response.out().write(reinterpret_cast<const char *>(&_buffer[0]), _bytesReadyCount);
 			_totalServedByteCount += _bytesReadyCount;
 			_bytesReadyCount = 0;
@@ -71,6 +73,8 @@ namespace Av
 			continuation->waitForMoreData();
 			_transcoder.asyncRead(_buffer.data(), _buffer.size(), [=](std::size_t nbBytesRead)
 			{
+				LMS_LOG(TRANSCODE, DEBUG) << "Have " << nbBytesRead << " more bytes to send back";
+
 				assert(_bytesReadyCount == 0);
 				_bytesReadyCount = nbBytesRead;
 				continuation->haveMoreData();
diff --git a/src/libs/services/CMakeLists.txt b/src/libs/services/CMakeLists.txt
index fd4d3160..70f360ed 100644
--- a/src/libs/services/CMakeLists.txt
+++ b/src/libs/services/CMakeLists.txt
@@ -1,6 +1,7 @@
 add_subdirectory(auth)
 add_subdirectory(cover)
 add_subdirectory(database)
+add_subdirectory(feedback)
 add_subdirectory(recommendation)
 add_subdirectory(scanner)
 add_subdirectory(scrobbling)
diff --git a/src/libs/services/cover/impl/CoverService.cpp b/src/libs/services/cover/impl/CoverService.cpp
index 86526dab..0912828e 100644
--- a/src/libs/services/cover/impl/CoverService.cpp
+++ b/src/libs/services/cover/impl/CoverService.cpp
@@ -34,445 +34,425 @@
 #include "utils/String.hpp"
 #include "utils/Utils.hpp"
 
-namespace
+namespace Cover
 {
-	struct TrackInfo
-	{
-		bool hasCover {};
-		bool isMultiDisc {};
-		std::filesystem::path trackPath;
-		std::optional<Database::ReleaseId> releaseId;
-	};
 
-	std::optional<TrackInfo>
-	getTrackInfo(Database::Session& dbSession, Database::TrackId trackId)
-	{
-		std::optional<TrackInfo> res;
+    namespace
+    {
+        struct TrackInfo
+        {
+            bool hasCover{};
+            bool isMultiDisc{};
+            std::filesystem::path trackPath;
+            std::optional<Database::ReleaseId> releaseId;
+        };
 
-		auto transaction {dbSession.createSharedTransaction()};
+        std::optional<TrackInfo> getTrackInfo(Database::Session& dbSession, Database::TrackId trackId)
+        {
+            std::optional<TrackInfo> res;
 
-		const Database::Track::pointer track {Database::Track::find(dbSession, trackId)};
-		if (!track)
-			return res;
+            auto transaction{ dbSession.createSharedTransaction() };
 
-		res = TrackInfo {};
+            const Database::Track::pointer track{ Database::Track::find(dbSession, trackId) };
+            if (!track)
+                return res;
 
-		res->hasCover = track->hasCover();
-		res->trackPath = track->getPath();
+            res = TrackInfo{};
 
-		if (const Database::Release::pointer& release {track->getRelease()})
-		{
-			res->releaseId = release->getId();
-			if (release->getTotalDisc() > 1)
-				res->isMultiDisc = true;
-		}
+            res->hasCover = track->hasCover();
+            res->trackPath = track->getPath();
 
-		return res;
-	}
+            if (const Database::Release::pointer & release{ track->getRelease() })
+            {
+                res->releaseId = release->getId();
+                if (release->getTotalDisc() > 1)
+                    res->isMultiDisc = true;
+            }
 
-	std::vector<std::string> constructPreferredFileNames()
-	{
-		std::vector<std::string> res;
+            return res;
+        }
 
-		Service<IConfig>::get()->visitStrings("cover-preferred-file-names",
-				[&res](std::string_view fileName)
-				{
-					res.emplace_back(fileName);
-				}, {"cover", "front"});
+        std::vector<std::string> constructPreferredFileNames()
+        {
+            std::vector<std::string> res;
 
-		return res;
-	}
-}
+            Service<IConfig>::get()->visitStrings("cover-preferred-file-names",
+                [&res](std::string_view fileName)
+                {
+                    res.emplace_back(fileName);
+                }, { "cover", "front" });
 
-namespace Cover {
+            return res;
+        }
 
-using namespace Image;
+        bool isFileSupported(const std::filesystem::path& file, const std::vector<std::filesystem::path>& extensions)
+        {
+            return (std::find(std::cbegin(extensions), std::cend(extensions), file.extension()) != std::cend(extensions));
+        }
+    }
 
-static
-bool
-isFileSupported(const std::filesystem::path& file, const std::vector<std::filesystem::path>& extensions)
-{
-	return (std::find(std::cbegin(extensions), std::cend(extensions), file.extension()) != std::cend(extensions));
-}
+    std::unique_ptr<ICoverService> createCoverService(Database::Db& db, const std::filesystem::path& execPath, const std::filesystem::path& defaultCoverPath)
+    {
+        return std::make_unique<CoverService>(db, execPath, defaultCoverPath);
+    }
 
-std::unique_ptr<ICoverService>
-createCoverService(Database::Db& db, const std::filesystem::path& execPath, const std::filesystem::path& defaultCoverPath)
-{
-	return std::make_unique<CoverService>(db, execPath, defaultCoverPath);
-}
+    using namespace Image;
 
-CoverService::CoverService(Database::Db& db,
-		const std::filesystem::path& execPath,
-		const std::filesystem::path& defaultCoverPath)
-	: _db {db}
-	, _defaultCoverPath {defaultCoverPath}
-	, _maxCacheSize {Service<IConfig>::get()->getULong("cover-max-cache-size", 30) * 1000 * 1000}
-	, _maxFileSize {Service<IConfig>::get()->getULong("cover-max-file-size", 10) * 1000 * 1000}
-	, _preferredFileNames {constructPreferredFileNames()}
+    CoverService::CoverService(Database::Db& db,
+        const std::filesystem::path& execPath,
+        const std::filesystem::path& defaultCoverPath)
+        : _db{ db }
+        , _defaultCoverPath{ defaultCoverPath }
+        , _maxCacheSize{ Service<IConfig>::get()->getULong("cover-max-cache-size", 30) * 1000 * 1000 }
+        , _maxFileSize{ Service<IConfig>::get()->getULong("cover-max-file-size", 10) * 1000 * 1000 }
+        , _preferredFileNames{ constructPreferredFileNames() }
 
-{
-	setJpegQuality(Service<IConfig>::get()->getULong("cover-jpeg-quality", 75));
+    {
+        setJpegQuality(Service<IConfig>::get()->getULong("cover-jpeg-quality", 75));
 
-	LMS_LOG(COVER, INFO) << "Default cover path = '" << _defaultCoverPath.string() << "'";
-	LMS_LOG(COVER, INFO) << "Max cache size = " << _maxCacheSize;
-	LMS_LOG(COVER, INFO) << "Max file size = " << _maxFileSize;
-	LMS_LOG(COVER, INFO) << "Preferred file names: " << StringUtils::joinStrings(_preferredFileNames, ",");
+        LMS_LOG(COVER, INFO) << "Default cover path = '" << _defaultCoverPath.string() << "'";
+        LMS_LOG(COVER, INFO) << "Max cache size = " << _maxCacheSize;
+        LMS_LOG(COVER, INFO) << "Max file size = " << _maxFileSize;
+        LMS_LOG(COVER, INFO) << "Preferred file names: " << StringUtils::joinStrings(_preferredFileNames, ",");
 
 #if LMS_SUPPORT_IMAGE_GM
-	GraphicsMagick::init(execPath);
+        GraphicsMagick::init(execPath);
 #else
-	(void)execPath;
+        (void)execPath;
 #endif
 
-	try
-	{
-		getDefault(512);
-	}
-	catch (const Image::ImageException& e)
-	{
-		throw LmsException("Cannot read default cover file '" + _defaultCoverPath.string() + "': " + e.what());
-	}
-}
-
-std::unique_ptr<IEncodedImage>
-CoverService::getFromAvMediaFile(const Av::IAudioFile& input, ImageSize width) const
-{
-	std::unique_ptr<IEncodedImage> image;
-
-	input.visitAttachedPictures([&](const Av::Picture& picture)
-	{
-		if (image)
-			return;
-
-		try
-		{
-			std::unique_ptr<IRawImage> rawImage {decodeImage(picture.data, picture.dataSize)};
-			rawImage->resize(width);
-			image = rawImage->encodeToJPEG(_jpegQuality);
-		}
-		catch (const Image::ImageException& e)
-		{
-			LMS_LOG(COVER, ERROR) << "Cannot read embedded cover: " << e.what();
-		}
-	});
-
-	return image;
-}
-
-std::unique_ptr<IEncodedImage>
-CoverService::getFromCoverFile(const std::filesystem::path& p, ImageSize width) const
-{
-	std::unique_ptr<IEncodedImage> image;
-
-	try
-	{
-		std::unique_ptr<IRawImage> rawImage {decodeImage(p)};
-		rawImage->resize(width);
-		image = rawImage->encodeToJPEG(_jpegQuality);
-	}
-	catch (const ImageException& e)
-	{
-		LMS_LOG(COVER, ERROR) << "Cannot read cover in file '" << p.string() << "': " << e.what();
-	}
-
-	return image;
-}
-
-std::shared_ptr<IEncodedImage>
-CoverService::getDefault(ImageSize width)
-{
-	{
-		std::shared_lock lock {_cacheMutex};
-
-		if (auto it {_defaultCoverCache.find(width)}; it != std::cend(_defaultCoverCache))
-			return it->second;
-	}
-
-	{
-		std::unique_lock lock {_cacheMutex};
-
-		if (auto it {_defaultCoverCache.find(width)}; it != std::cend(_defaultCoverCache))
-			return it->second;
-
-		std::shared_ptr<IEncodedImage> image {getFromCoverFile(_defaultCoverPath, width)};
-		_defaultCoverCache[width] = image;
-		LMS_LOG(COVER, DEBUG) << "Default cache entries = " << _defaultCoverCache.size();
-
-		return image;
-	}
-}
-
-std::unique_ptr<IEncodedImage>
-CoverService::getFromDirectory(const std::filesystem::path& directory, ImageSize width) const
-{
-	const std::multimap<std::string, std::filesystem::path> coverPaths {getCoverPaths(directory)};
-
-	auto tryLoadImageFromFilename = [&](std::string_view fileName)
-	{
-		std::unique_ptr<IEncodedImage> image;
-
-		auto range {coverPaths.equal_range(std::string {fileName})};
-		for (auto it {range.first}; it != range.second; ++it)
-		{
-			image = getFromCoverFile(it->second, width);
-			if (image)
-				break;
-		}
-		return image;
-	};
-
-	std::unique_ptr<IEncodedImage> image;
-
-	for (std::string_view filename : _preferredFileNames)
-	{
-		image = tryLoadImageFromFilename(filename);
-		if (image)
-			return image;
-	}
-
-	// Just pick one
-	for (const auto& [filename, coverPath] : coverPaths)
-	{
-		image = getFromCoverFile(coverPath, width);
-		if (image)
-			return image;
-	}
-
-	return image;
-}
-
-std::unique_ptr<IEncodedImage>
-CoverService::getFromSameNamedFile(const std::filesystem::path& filePath, ImageSize width) const
-{
-	std::unique_ptr<IEncodedImage> res;
-
-	std::filesystem::path coverPath {filePath};
-	for (const std::filesystem::path& extension : _fileExtensions)
-	{
-		coverPath.replace_extension(extension);
-
-		if (!checkCoverFile(coverPath))
-			continue;
-
-		res = getFromCoverFile(coverPath, width);
-		if (res)
-			break;
-	}
-
-	return res;
-}
-
-bool
-CoverService::checkCoverFile(const std::filesystem::path& filePath) const
-{
-	std::error_code ec;
-
-	if (!isFileSupported(filePath, _fileExtensions))
-		return false;
-
-	if (!std::filesystem::exists(filePath, ec))
-		return false;
-
-	if (!std::filesystem::is_regular_file(filePath, ec))
-		return false;
-
-	if (std::filesystem::file_size(filePath, ec) > _maxFileSize && !ec)
-	{
-		LMS_LOG(COVER, INFO) << "Cover file '" << filePath.string() << " is too big (" << std::filesystem::file_size(filePath, ec) << "), limit is " << _maxFileSize;
-		return false;
-	}
-
-	return true;
-}
-
-std::multimap<std::string, std::filesystem::path>
-CoverService::getCoverPaths(const std::filesystem::path& directoryPath) const
-{
-	std::multimap<std::string, std::filesystem::path> res;
-	std::error_code ec;
-
-	std::filesystem::directory_iterator itPath(directoryPath, ec);
-	std::filesystem::directory_iterator itEnd;
-	while (!ec && itPath != itEnd)
-	{
-		const std::filesystem::path& path {*itPath};
-
-		if (checkCoverFile(path))
-			res.emplace(std::filesystem::path{ path }.filename().replace_extension("").string(), path);
-
-		itPath.increment(ec);
-	}
-
-	return res;
-}
-
-std::unique_ptr<IEncodedImage>
-CoverService::getFromTrack(const std::filesystem::path& p, ImageSize width) const
-{
-	std::unique_ptr<IEncodedImage> image;
-
-	try
-	{
-		image = getFromAvMediaFile(*Av::parseAudioFile(p), width);
-	}
-	catch (Av::Exception& e)
-	{
-		LMS_LOG(COVER, ERROR) << "Cannot get covers from track " << p.string() << ": " << e.what();
-	}
-
-	return image;
-}
-
-std::shared_ptr<IEncodedImage>
-CoverService::getFromTrack(Database::TrackId trackId, ImageSize width)
-{
-	return getFromTrack(_db.getTLSSession(), trackId, width, true /* allow release fallback*/);
-}
-
-std::shared_ptr<IEncodedImage>
-CoverService::getFromTrack(Database::Session& dbSession, Database::TrackId trackId, ImageSize width, bool allowReleaseFallback)
-{
-	using namespace Database;
-
-	const CacheEntryDesc cacheEntryDesc {trackId, width};
-
-	std::shared_ptr<IEncodedImage> cover {loadFromCache(cacheEntryDesc)};
-	if (cover)
-		return cover;
-
-	if (const std::optional<TrackInfo> trackInfo {getTrackInfo(dbSession, trackId)})
-	{
-		if (trackInfo->hasCover)
-			cover = getFromTrack(trackInfo->trackPath, width);
-
-		if (!cover)
-			cover = getFromSameNamedFile(trackInfo->trackPath, width);
-
-		if (!cover && trackInfo->releaseId && allowReleaseFallback)
-			cover = getFromRelease(*trackInfo->releaseId, width);
-
-		if (!cover && trackInfo->isMultiDisc)
-		{
-			if (trackInfo->trackPath.parent_path().has_parent_path())
-				cover = getFromDirectory(trackInfo->trackPath.parent_path().parent_path(), width);
-		}
-	}
-
-	if (!cover)
-		cover = getDefault(width);
-
-	if (cover)
-		saveToCache(cacheEntryDesc, cover);
-
-	return cover;
-}
-
-std::shared_ptr<IEncodedImage>
-CoverService::getFromRelease(Database::ReleaseId releaseId, ImageSize width)
-{
-	using namespace Database;
-	const CacheEntryDesc cacheEntryDesc {releaseId, width};
-
-	std::shared_ptr<IEncodedImage> cover {loadFromCache(cacheEntryDesc)};
-	if (cover)
-		return cover;
-
-	struct ReleaseInfo
-	{
-		TrackId firstTrackId;
-		std::filesystem::path releaseDirectory;
-	};
-
-	Session& session {_db.getTLSSession()};
-
-	auto getReleaseInfo {[&]
-	{
-		std::optional<ReleaseInfo> res;
-
-		auto transaction {session.createSharedTransaction()};
-
-		const auto tracks {Track::find(session, Track::FindParameters {}.setRelease(releaseId).setRange({0, 1}).setSortMethod(TrackSortMethod::Release))};
-
-		if (!tracks.results.empty())
-		{
-			if (const Track::pointer track {Track::find(session, tracks.results.front())})
-			{
-				res = ReleaseInfo {};
-				res->firstTrackId = track->getId();
-				res->releaseDirectory = track->getPath().parent_path();
-			}
-		}
-
-		return res;
-	}};
-
-	if (const std::optional<ReleaseInfo> releaseInfo {getReleaseInfo()})
-	{
-		cover = getFromDirectory(releaseInfo->releaseDirectory, width);
-		if (!cover)
-			cover = getFromTrack(session, releaseInfo->firstTrackId, width, false /* no release fallback */);
-	}
-
-	if (!cover)
-		cover = getDefault(width);
-
-	if (cover)
-		saveToCache(cacheEntryDesc, cover);
-
-	return cover;
-}
-
-void
-CoverService::flushCache()
-{
-	std::unique_lock lock {_cacheMutex};
-
-	LMS_LOG(COVER, DEBUG) << "Cache stats: hits = " << _cacheHits << ", misses = " << _cacheMisses << ", nb entries = " << _cache.size() << ", size = " << _cacheSize;
-	_cacheHits = 0;
-	_cacheMisses = 0;
-	_cacheSize = 0;
-	_cache.clear();
-}
-
-void
-CoverService::setJpegQuality(unsigned quality)
-{
-	_jpegQuality = Utils::clamp<unsigned>(quality, 1, 100);
-
-	LMS_LOG(COVER, INFO) << "JPEG export quality = " << _jpegQuality;
-}
-
-void
-CoverService::saveToCache(const CacheEntryDesc& entryDesc, std::shared_ptr<IEncodedImage> image)
-{
-	std::unique_lock lock {_cacheMutex};
-
-	while (_cacheSize + image->getDataSize() > _maxCacheSize && !_cache.empty())
-	{
-		auto itRandom {Random::pickRandom(_cache)};
-		_cacheSize -= itRandom->second->getDataSize();
-		_cache.erase(itRandom);
-	}
-
-	_cacheSize += image->getDataSize();
-	_cache[entryDesc] = image;
-}
-
-std::shared_ptr<IEncodedImage>
-CoverService::loadFromCache(const CacheEntryDesc& entryDesc)
-{
-	std::shared_lock lock {_cacheMutex};
-
-	auto it {_cache.find(entryDesc)};
-	if (it == std::cend(_cache))
-	{
-		++_cacheMisses;
-		return nullptr;
-	}
-
-	++_cacheHits;
-	return it->second;
-}
+        try
+        {
+            getDefault(512);
+        }
+        catch (const Image::ImageException& e)
+        {
+            throw LmsException("Cannot read default cover file '" + _defaultCoverPath.string() + "': " + e.what());
+        }
+    }
+
+    std::unique_ptr<IEncodedImage> CoverService::getFromAvMediaFile(const Av::IAudioFile& input, ImageSize width) const
+    {
+        std::unique_ptr<IEncodedImage> image;
+
+        input.visitAttachedPictures([&](const Av::Picture& picture)
+            {
+                if (image)
+                    return;
+
+                try
+                {
+                    std::unique_ptr<IRawImage> rawImage{ decodeImage(picture.data, picture.dataSize) };
+                    rawImage->resize(width);
+                    image = rawImage->encodeToJPEG(_jpegQuality);
+                }
+                catch (const Image::ImageException& e)
+                {
+                    LMS_LOG(COVER, ERROR) << "Cannot read embedded cover: " << e.what();
+                }
+            });
+
+        return image;
+    }
+
+    std::unique_ptr<IEncodedImage> CoverService::getFromCoverFile(const std::filesystem::path& p, ImageSize width) const
+    {
+        std::unique_ptr<IEncodedImage> image;
+
+        try
+        {
+            std::unique_ptr<IRawImage> rawImage{ decodeImage(p) };
+            rawImage->resize(width);
+            image = rawImage->encodeToJPEG(_jpegQuality);
+        }
+        catch (const ImageException& e)
+        {
+            LMS_LOG(COVER, ERROR) << "Cannot read cover in file '" << p.string() << "': " << e.what();
+        }
+
+        return image;
+    }
+
+    std::shared_ptr<IEncodedImage> CoverService::getDefault(ImageSize width)
+    {
+        {
+            std::shared_lock lock{ _cacheMutex };
+
+            if (auto it{ _defaultCoverCache.find(width) }; it != std::cend(_defaultCoverCache))
+                return it->second;
+        }
+
+        {
+            std::unique_lock lock{ _cacheMutex };
+
+            if (auto it{ _defaultCoverCache.find(width) }; it != std::cend(_defaultCoverCache))
+                return it->second;
+
+            std::shared_ptr<IEncodedImage> image{ getFromCoverFile(_defaultCoverPath, width) };
+            _defaultCoverCache[width] = image;
+            LMS_LOG(COVER, DEBUG) << "Default cache entries = " << _defaultCoverCache.size();
+
+            return image;
+        }
+    }
+
+    std::unique_ptr<IEncodedImage> CoverService::getFromDirectory(const std::filesystem::path& directory, ImageSize width) const
+    {
+        const std::multimap<std::string, std::filesystem::path> coverPaths{ getCoverPaths(directory) };
+
+        auto tryLoadImageFromFilename = [&](std::string_view fileName)
+            {
+                std::unique_ptr<IEncodedImage> image;
+
+                auto range{ coverPaths.equal_range(std::string {fileName}) };
+                for (auto it{ range.first }; it != range.second; ++it)
+                {
+                    image = getFromCoverFile(it->second, width);
+                    if (image)
+                        break;
+                }
+                return image;
+            };
+
+        std::unique_ptr<IEncodedImage> image;
+
+        for (std::string_view filename : _preferredFileNames)
+        {
+            image = tryLoadImageFromFilename(filename);
+            if (image)
+                return image;
+        }
+
+        // Just pick one
+        for (const auto& [filename, coverPath] : coverPaths)
+        {
+            image = getFromCoverFile(coverPath, width);
+            if (image)
+                return image;
+        }
+
+        return image;
+    }
+
+    std::unique_ptr<IEncodedImage> CoverService::getFromSameNamedFile(const std::filesystem::path& filePath, ImageSize width) const
+    {
+        std::unique_ptr<IEncodedImage> res;
+
+        std::filesystem::path coverPath{ filePath };
+        for (const std::filesystem::path& extension : _fileExtensions)
+        {
+            coverPath.replace_extension(extension);
+
+            if (!checkCoverFile(coverPath))
+                continue;
+
+            res = getFromCoverFile(coverPath, width);
+            if (res)
+                break;
+        }
+
+        return res;
+    }
+
+    bool CoverService::checkCoverFile(const std::filesystem::path& filePath) const
+    {
+        std::error_code ec;
+
+        if (!isFileSupported(filePath, _fileExtensions))
+            return false;
+
+        if (!std::filesystem::exists(filePath, ec))
+            return false;
+
+        if (!std::filesystem::is_regular_file(filePath, ec))
+            return false;
+
+        if (std::filesystem::file_size(filePath, ec) > _maxFileSize && !ec)
+        {
+            LMS_LOG(COVER, INFO) << "Cover file '" << filePath.string() << " is too big (" << std::filesystem::file_size(filePath, ec) << "), limit is " << _maxFileSize;
+            return false;
+        }
+
+        return true;
+    }
+
+    std::multimap<std::string, std::filesystem::path> CoverService::getCoverPaths(const std::filesystem::path& directoryPath) const
+    {
+        std::multimap<std::string, std::filesystem::path> res;
+        std::error_code ec;
+
+        std::filesystem::directory_iterator itPath(directoryPath, ec);
+        std::filesystem::directory_iterator itEnd;
+        while (!ec && itPath != itEnd)
+        {
+            const std::filesystem::path& path{ *itPath };
+
+            if (checkCoverFile(path))
+                res.emplace(std::filesystem::path{ path }.filename().replace_extension("").string(), path);
+
+            itPath.increment(ec);
+        }
+
+        return res;
+    }
+
+    std::unique_ptr<IEncodedImage> CoverService::getFromTrack(const std::filesystem::path& p, ImageSize width) const
+    {
+        std::unique_ptr<IEncodedImage> image;
+
+        try
+        {
+            image = getFromAvMediaFile(*Av::parseAudioFile(p), width);
+        }
+        catch (Av::Exception& e)
+        {
+            LMS_LOG(COVER, ERROR) << "Cannot get covers from track " << p.string() << ": " << e.what();
+        }
+
+        return image;
+    }
+
+    std::shared_ptr<IEncodedImage> CoverService::getFromTrack(Database::TrackId trackId, ImageSize width)
+    {
+        return getFromTrack(_db.getTLSSession(), trackId, width, true /* allow release fallback*/);
+    }
+
+    std::shared_ptr<IEncodedImage> CoverService::getFromTrack(Database::Session& dbSession, Database::TrackId trackId, ImageSize width, bool allowReleaseFallback)
+    {
+        using namespace Database;
+
+        const CacheEntryDesc cacheEntryDesc{ trackId, width };
+
+        std::shared_ptr<IEncodedImage> cover{ loadFromCache(cacheEntryDesc) };
+        if (cover)
+            return cover;
+
+        if (const std::optional<TrackInfo> trackInfo{ getTrackInfo(dbSession, trackId) })
+        {
+            if (trackInfo->hasCover)
+                cover = getFromTrack(trackInfo->trackPath, width);
+
+            if (!cover)
+                cover = getFromSameNamedFile(trackInfo->trackPath, width);
+
+            if (!cover && trackInfo->releaseId && allowReleaseFallback)
+                cover = getFromRelease(*trackInfo->releaseId, width);
+
+            if (!cover && trackInfo->isMultiDisc)
+            {
+                if (trackInfo->trackPath.parent_path().has_parent_path())
+                    cover = getFromDirectory(trackInfo->trackPath.parent_path().parent_path(), width);
+            }
+        }
+
+        if (!cover)
+            cover = getDefault(width);
+
+        if (cover)
+            saveToCache(cacheEntryDesc, cover);
+
+        return cover;
+    }
+
+    std::shared_ptr<IEncodedImage> CoverService::getFromRelease(Database::ReleaseId releaseId, ImageSize width)
+    {
+        using namespace Database;
+        const CacheEntryDesc cacheEntryDesc{ releaseId, width };
+
+        std::shared_ptr<IEncodedImage> cover{ loadFromCache(cacheEntryDesc) };
+        if (cover)
+            return cover;
+
+        struct ReleaseInfo
+        {
+            TrackId firstTrackId;
+            std::filesystem::path releaseDirectory;
+        };
+
+        Session& session{ _db.getTLSSession() };
+
+        auto getReleaseInfo{ [&]
+        {
+            std::optional<ReleaseInfo> res;
+
+            auto transaction{ session.createSharedTransaction() };
+
+            const auto tracks{ Track::find(session, Track::FindParameters {}.setRelease(releaseId).setRange({0, 1}).setSortMethod(TrackSortMethod::Release)) };
+
+            if (!tracks.results.empty())
+            {
+                const Track::pointer& track{ tracks.results.front() };
+                res = ReleaseInfo{};
+                res->firstTrackId = track->getId();
+                res->releaseDirectory = track->getPath().parent_path();
+            }
+
+            return res;
+        } };
+
+        if (const std::optional<ReleaseInfo> releaseInfo{ getReleaseInfo() })
+        {
+            cover = getFromDirectory(releaseInfo->releaseDirectory, width);
+            if (!cover)
+                cover = getFromTrack(session, releaseInfo->firstTrackId, width, false /* no release fallback */);
+        }
+
+        if (!cover)
+            cover = getDefault(width);
+
+        if (cover)
+            saveToCache(cacheEntryDesc, cover);
+
+        return cover;
+    }
+
+    void CoverService::flushCache()
+    {
+        std::unique_lock lock{ _cacheMutex };
+
+        LMS_LOG(COVER, DEBUG) << "Cache stats: hits = " << _cacheHits << ", misses = " << _cacheMisses << ", nb entries = " << _cache.size() << ", size = " << _cacheSize;
+        _cacheHits = 0;
+        _cacheMisses = 0;
+        _cacheSize = 0;
+        _cache.clear();
+    }
+
+    void CoverService::setJpegQuality(unsigned quality)
+    {
+        _jpegQuality = Utils::clamp<unsigned>(quality, 1, 100);
+
+        LMS_LOG(COVER, INFO) << "JPEG export quality = " << _jpegQuality;
+    }
+
+    void CoverService::saveToCache(const CacheEntryDesc& entryDesc, std::shared_ptr<IEncodedImage> image)
+    {
+        std::unique_lock lock{ _cacheMutex };
+
+        while (_cacheSize + image->getDataSize() > _maxCacheSize && !_cache.empty())
+        {
+            auto itRandom{ Random::pickRandom(_cache) };
+            _cacheSize -= itRandom->second->getDataSize();
+            _cache.erase(itRandom);
+        }
+
+        _cacheSize += image->getDataSize();
+        _cache[entryDesc] = image;
+    }
+
+    std::shared_ptr<IEncodedImage> CoverService::loadFromCache(const CacheEntryDesc& entryDesc)
+    {
+        std::shared_lock lock{ _cacheMutex };
+
+        auto it{ _cache.find(entryDesc) };
+        if (it == std::cend(_cache))
+        {
+            ++_cacheMisses;
+            return nullptr;
+        }
+
+        ++_cacheHits;
+        return it->second;
+    }
 
 } // namespace Cover
 
diff --git a/src/libs/services/database/impl/Artist.cpp b/src/libs/services/database/impl/Artist.cpp
index 1bbfbfeb..c9ca60a4 100644
--- a/src/libs/services/database/impl/Artist.cpp
+++ b/src/libs/services/database/impl/Artist.cpp
@@ -33,278 +33,298 @@
 
 namespace Database
 {
+    namespace
+    {
+        template <typename ResultType>
+        Wt::Dbo::Query<ResultType> createQuery(Session& session, std::string_view itemToSelect, const Artist::FindParameters& params)
+        {
+            session.checkSharedLocked();
 
-Artist::Artist(const std::string& name, const std::optional<UUID>& MBID)
-: _name {std::string(name, 0 , _maxNameLength)},
-_sortName {_name},
-_MBID {MBID ? MBID->getAsString() : ""}
-{
-}
+            auto query{ session.getDboSession().query<ResultType>("SELECT DISTINCT " + std::string{ itemToSelect } + " FROM artist a") };
+            if (params.sortMethod == ArtistSortMethod::LastWritten
+                || params.writtenAfter.isValid()
+                || params.linkType
+                || params.track.isValid()
+                || params.release.isValid()
+                || params.clusters.size() == 1)
+            {
+                query.join("track t ON t.id = t_a_l.track_id");
+                query.join("track_artist_link t_a_l ON t_a_l.artist_id = a.id");
+            }
 
-Artist::pointer
-Artist::create(Session& session, const std::string& name, const std::optional<UUID>& MBID)
-{
-	return session.getDboSession().add(std::unique_ptr<Artist> {new Artist {name, MBID}});
-}
+            if (params.linkType)
+                query.where("t_a_l.type = ?").bind(*params.linkType);
 
-std::size_t
-Artist::getCount(Session& session)
-{
-	session.checkSharedLocked();
+            if (params.writtenAfter.isValid())
+                query.where("t.file_last_write > ?").bind(params.writtenAfter);
 
-	return session.getDboSession().query<int>("SELECT COUNT(*) FROM artist");
-}
+            if (!params.keywords.empty())
+            {
+                std::vector<std::string> clauses;
+                std::vector<std::string> sortClauses;
 
-std::vector<Artist::pointer>
-Artist::find(Session& session, const std::string& name)
-{
-	session.checkSharedLocked();
+                for (std::string_view keyword : params.keywords)
+                {
+                    clauses.push_back("a.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
+                    query.bind("%" + Utils::escapeLikeKeyword(keyword) + "%");
+                }
 
-	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res = session.getDboSession().find<Artist>()
-		.where("name = ?").bind(std::string {name, 0, _maxNameLength})
-		.orderBy("LENGTH(mbid) DESC"); // put mbid entries first
+                for (std::string_view keyword : params.keywords)
+                {
+                    sortClauses.push_back("a.sort_name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
+                    query.bind("%" + Utils::escapeLikeKeyword(keyword) + "%");
+                }
 
-	return std::vector<Artist::pointer>(res.begin(), res.end());
-}
+                query.where("(" + StringUtils::joinStrings(clauses, " AND ") + ") OR (" + StringUtils::joinStrings(sortClauses, " AND ") + ")");
+            }
 
-Artist::pointer
-Artist::find(Session& session, const UUID& mbid)
-{
-	session.checkSharedLocked();
-	return session.getDboSession().find<Artist>().where("mbid = ?").bind(std::string {mbid.getAsString()}).resultValue();
-}
+            if (params.starringUser.isValid())
+            {
+                assert(params.feedbackBackend);
+                query.join("starred_artist s_a ON s_a.artist_id = a.id")
+                    .where("s_a.user_id = ?").bind(params.starringUser)
+                    .where("s_a.backend = ?").bind(*params.feedbackBackend)
+                    .where("s_a.sync_state <> ?").bind(SyncState::PendingRemove);
+            }
 
-Artist::pointer
-Artist::find(Session& session, ArtistId id)
-{
-	session.checkSharedLocked();
-	return session.getDboSession().find<Artist>().where("id = ?").bind(id).resultValue();
-}
+            if (params.clusters.size() == 1)
+            {
+                query.join("track_cluster t_c ON t_c.track_id = t.id")
+                    .where("t_c.cluster_id = ?").bind(params.clusters.front());
+            }
+            else if (params.clusters.size() > 1)
+            {
+                std::ostringstream oss;
+                oss << "a.id IN (SELECT DISTINCT a.id FROM artist a"
+                    " INNER JOIN track t ON t.id = t_a_l.track_id"
+                    " INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
+                    " INNER JOIN cluster c ON c.id = t_c.cluster_id"
+                    " INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
 
-bool
-Artist::exists(Session& session, ArtistId id)
-{
-	session.checkSharedLocked();
-	return session.getDboSession().query<int>("SELECT 1 FROM artist").where("id = ?").bind(id).resultValue() == 1;
-}
+                WhereClause clusterClause;
+                for (const ClusterId clusterId : params.clusters)
+                {
+                    clusterClause.Or(WhereClause("c.id = ?"));
+                    query.bind(clusterId);
+                }
 
-static
-Wt::Dbo::Query<ArtistId>
-createQuery(Session& session, const Artist::FindParameters& params)
-{
-	session.checkSharedLocked();
+                oss << " " << clusterClause.get();
+                oss << " GROUP BY t.id,a.id HAVING COUNT(DISTINCT c.id) = " << params.clusters.size() << ")";
 
-	auto query {session.getDboSession().query<ArtistId>("SELECT DISTINCT a.id FROM artist a")};
-	if (params.sortMethod == ArtistSortMethod::LastWritten
-			|| params.writtenAfter.isValid()
-			|| params.linkType
-			|| params.track.isValid()
-			|| params.release.isValid())
-	{
-		query.join("track t ON t.id = t_a_l.track_id");
-		query.join("track_artist_link t_a_l ON t_a_l.artist_id = a.id");
-	}
+                query.where(oss.str());
+            }
 
-	if (params.linkType)
-		query.where("t_a_l.type = ?").bind(*params.linkType);
+            if (params.track.isValid())
+                query.where("t.id = ?").bind(params.track);
 
-	if (params.writtenAfter.isValid())
-		query.where("t.file_last_write > ?").bind(params.writtenAfter);
+            if (params.release.isValid())
+                query.where("t.release_id = ?").bind(params.release);
 
-	if (!params.keywords.empty())
-	{
-		std::vector<std::string> clauses;
-		std::vector<std::string> sortClauses;
+            switch (params.sortMethod)
+            {
+            case ArtistSortMethod::None:
+                break;
+            case ArtistSortMethod::ByName:
+                query.orderBy("a.name COLLATE NOCASE");
+                break;
+            case ArtistSortMethod::BySortName:
+                query.orderBy("a.sort_name COLLATE NOCASE");
+                break;
+            case ArtistSortMethod::Random:
+                query.orderBy("RANDOM()");
+                break;
+            case ArtistSortMethod::LastWritten:
+                query.orderBy("t.file_last_write DESC");
+                break;
+            case ArtistSortMethod::StarredDateDesc:
+                assert(params.starringUser.isValid());
+                query.orderBy("s_a.date_time DESC");
+                break;
+            }
 
-		for (std::string_view keyword : params.keywords)
-		{
-			clauses.push_back("a.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
-			query.bind("%" + Utils::escapeLikeKeyword(keyword) + "%");
-		}
+            return query;
+        }
 
-		for (std::string_view keyword : params.keywords)
-		{
-			sortClauses.push_back("a.sort_name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
-			query.bind("%" + Utils::escapeLikeKeyword(keyword) + "%");
-		}
+        template <typename ResultType>
+        Wt::Dbo::Query<ResultType> createQuery(Session& session, const Artist::FindParameters& params)
+        {
+            std::string_view itemToSelect;
+            
+            if constexpr (std::is_same_v<ResultType, ArtistId>)
+                itemToSelect = "a.id";
+            else if constexpr (std::is_same_v<ResultType, Wt::Dbo::ptr<Artist>>)
+                itemToSelect = "a";
+            else
+                static_assert("Unhandled type");
 
-		query.where("(" + StringUtils::joinStrings(clauses, " AND ") + ") OR (" + StringUtils::joinStrings(sortClauses, " AND ") + ")");
-	}
+            return createQuery<ResultType>(session, itemToSelect, params);
+        }
+    }
 
-	if (params.starringUser.isValid())
-	{
-		assert(params.scrobbler);
-		query.join("starred_artist s_a ON s_a.artist_id = a.id")
-			.where("s_a.user_id = ?").bind(params.starringUser)
-			.where("s_a.scrobbler = ?").bind(*params.scrobbler)
-			.where("s_a.scrobbling_state <> ?").bind(ScrobblingState::PendingRemove);
-	}
+    Artist::Artist(const std::string& name, const std::optional<UUID>& MBID)
+        : _name{ std::string(name, 0 , _maxNameLength) },
+        _sortName{ _name },
+        _MBID{ MBID ? MBID->getAsString() : "" }
+    {
+    }
 
-	if (!params.clusters.empty())
-	{
-		std::ostringstream oss;
-		oss << "a.id IN (SELECT DISTINCT a.id FROM artist a"
-			" INNER JOIN track t ON t.id = t_a_l.track_id"
-			" INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
-			" INNER JOIN cluster c ON c.id = t_c.cluster_id"
-			" INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
+    Artist::pointer Artist::create(Session& session, const std::string& name, const std::optional<UUID>& MBID)
+    {
+        return session.getDboSession().add(std::unique_ptr<Artist> {new Artist{ name, MBID }});
+    }
 
-		WhereClause clusterClause;
-		for (const ClusterId clusterId : params.clusters)
-		{
-			clusterClause.Or(WhereClause("c.id = ?"));
-			query.bind(clusterId);
-		}
+    std::size_t Artist::getCount(Session& session)
+    {
+        session.checkSharedLocked();
 
-		oss << " " << clusterClause.get();
-		oss << " GROUP BY t.id,a.id HAVING COUNT(DISTINCT c.id) = " << params.clusters.size() << ")";
+        return session.getDboSession().query<int>("SELECT COUNT(*) FROM artist");
+    }
 
-		query.where(oss.str());
-	}
+    std::vector<Artist::pointer> Artist::find(Session& session, const std::string& name)
+    {
+        session.checkSharedLocked();
 
-	if (params.track.isValid())
-		query.where("t.id = ?").bind(params.track);
+        Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res = session.getDboSession().find<Artist>()
+            .where("name = ?").bind(std::string{ name, 0, _maxNameLength })
+            .orderBy("LENGTH(mbid) DESC"); // put mbid entries first
 
-	if (params.release.isValid())
-		query.where("t.release_id = ?").bind(params.release);
+        return std::vector<Artist::pointer>(res.begin(), res.end());
+    }
 
-	switch (params.sortMethod)
-	{
-		case ArtistSortMethod::None:
-			break;
-		case ArtistSortMethod::ByName:
-			query.orderBy("a.name COLLATE NOCASE");
-			break;
-		case ArtistSortMethod::BySortName:
-			query.orderBy("a.sort_name COLLATE NOCASE");
-			break;
-		case ArtistSortMethod::Random:
-			query.orderBy("RANDOM()");
-			break;
-		case ArtistSortMethod::LastWritten:
-			query.orderBy("t.file_last_write DESC");
-			break;
-		case ArtistSortMethod::StarredDateDesc:
-			assert(params.starringUser.isValid());
-			query.orderBy("s_a.date_time DESC");
-			break;
-	}
+    Artist::pointer Artist::find(Session& session, const UUID& mbid)
+    {
+        session.checkSharedLocked();
+        return session.getDboSession().find<Artist>().where("mbid = ?").bind(std::string{ mbid.getAsString() }).resultValue();
+    }
 
-	return query;
-}
+    Artist::pointer Artist::find(Session& session, ArtistId id)
+    {
+        session.checkSharedLocked();
+        return session.getDboSession().find<Artist>().where("id = ?").bind(id).resultValue();
+    }
 
-RangeResults<ArtistId>
-Artist::findAllOrphans(Session& session, Range range)
-{
-	session.checkSharedLocked();
-	auto query {session.getDboSession().query<ArtistId>("SELECT DISTINCT a.id FROM artist a WHERE NOT EXISTS(SELECT 1 FROM track t INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id WHERE t.id = t_a_l.track_id)")};
+    bool Artist::exists(Session& session, ArtistId id)
+    {
+        session.checkSharedLocked();
+        return session.getDboSession().query<int>("SELECT 1 FROM artist").where("id = ?").bind(id).resultValue() == 1;
+    }
 
-	return Utils::execQuery(query, range);
-}
 
-RangeResults<ArtistId>
-Artist::find(Session& session, const FindParameters& params)
-{
-	session.checkSharedLocked();
+    RangeResults<ArtistId> Artist::findOrphanIds(Session& session, Range range)
+    {
+        session.checkSharedLocked();
+        auto query{ session.getDboSession().query<ArtistId>("SELECT DISTINCT a.id FROM artist a WHERE NOT EXISTS(SELECT 1 FROM track t INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id WHERE t.id = t_a_l.track_id)") };
 
-	auto query {createQuery(session, params)};
-	return Utils::execQuery(query, params.range);
-}
+        return Utils::execQuery(query, range);
+    }
 
-RangeResults<ArtistId>
-Artist::findSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes, Range range) const
-{
-	assert(session());
+    RangeResults<ArtistId> Artist::findIds(Session& session, const FindParameters& params)
+    {
+        session.checkSharedLocked();
 
-	std::ostringstream oss;
-	oss <<
-			"SELECT a.id FROM artist a"
-			" INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
-			" INNER JOIN track t ON t.id = t_a_l.track_id"
-			" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
-				" WHERE "
-					" t_c.cluster_id IN (SELECT c.id from cluster c"
-											" INNER JOIN track t ON c.id = t_c.cluster_id"
-											" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
-											" INNER JOIN artist a ON a.id = t_a_l.artist_id"
-											" INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id"
-											" WHERE a.id = ?)"
-					" AND a.id <> ?";
+        auto query{ createQuery<ArtistId>(session, params) };
+        return Utils::execQuery(query, params.range);
+    }
 
-	if (!artistLinkTypes.empty())
-	{
-		oss << " AND t_a_l.type IN (";
+    RangeResults<Artist::pointer> Artist::find(Session& session, const FindParameters& params)
+    {
+        session.checkSharedLocked();
 
-		bool first {true};
-		for (TrackArtistLinkType type : artistLinkTypes)
-		{
-			(void) type;
-			if (!first)
-				oss << ", ";
-			oss << "?";
-			first = false;
-		}
-		oss << ")";
-	}
+        auto query{ createQuery<Wt::Dbo::ptr<Artist>>(session, params) };
+        return Utils::execQuery(query, params.range);
+    }
 
-	auto query {session()->query<ArtistId>(oss.str())
-		.bind(getId())
-		.bind(getId())
-		.groupBy("a.id")
-		.orderBy("COUNT(*) DESC, RANDOM()")};
+    RangeResults<ArtistId> Artist::findSimilarArtistIds(EnumSet<TrackArtistLinkType> artistLinkTypes, Range range) const
+    {
+        assert(session());
 
-	for (TrackArtistLinkType type : artistLinkTypes)
-		query.bind(type);
+        std::ostringstream oss;
+        oss <<
+            "SELECT a.id FROM artist a"
+            " INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
+            " INNER JOIN track t ON t.id = t_a_l.track_id"
+            " INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
+            " WHERE "
+            " t_c.cluster_id IN (SELECT DISTINCT c.id from cluster c"
+            " INNER JOIN track t ON c.id = t_c.cluster_id"
+            " INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
+            " INNER JOIN artist a ON a.id = t_a_l.artist_id"
+            " INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id"
+            " WHERE a.id = ?)"
+            " AND a.id <> ?";
 
-	return Utils::execQuery(query, range);
-}
+        if (!artistLinkTypes.empty())
+        {
+            oss << " AND t_a_l.type IN (";
 
-std::vector<std::vector<Cluster::pointer>>
-Artist::getClusterGroups(std::vector<ClusterType::pointer> clusterTypes, std::size_t size) const
-{
-	assert(session());
+            bool first{ true };
+            for (TrackArtistLinkType type : artistLinkTypes)
+            {
+                (void)type;
+                if (!first)
+                    oss << ", ";
+                oss << "?";
+                first = false;
+            }
+            oss << ")";
+        }
 
-	WhereClause where;
+        auto query{ session()->query<ArtistId>(oss.str())
+            .bind(getId())
+            .bind(getId())
+            .groupBy("a.id")
+            .orderBy("COUNT(*) DESC, RANDOM()") };
 
-	std::ostringstream oss;
-	oss << "SELECT c FROM cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN cluster_type c_type ON c.cluster_type_id = c_type.id INNER JOIN artist a ON t_a_l.artist_id = a.id INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id";
+        for (TrackArtistLinkType type : artistLinkTypes)
+            query.bind(type);
 
-	where.And(WhereClause("a.id = ?")).bind(getId().toString());
-	{
-		WhereClause clusterClause;
-		for (auto clusterType : clusterTypes)
-			clusterClause.Or(WhereClause("c_type.id = ?")).bind(clusterType->getId().toString());
+        return Utils::execQuery(query, range);
+    }
 
-		where.And(clusterClause);
-	}
-	oss << " " << where.get();
-	oss << "GROUP BY c.id ORDER BY COUNT(DISTINCT c.id) DESC";
+    std::vector<std::vector<Cluster::pointer>> Artist::getClusterGroups(std::vector<ClusterType::pointer> clusterTypes, std::size_t size) const
+    {
+        assert(session());
 
-	Wt::Dbo::Query<Wt::Dbo::ptr<Cluster>> query = session()->query<Wt::Dbo::ptr<Cluster>>( oss.str() );
+        WhereClause where;
 
-	for (const std::string& bindArg : where.getBindArgs())
-		query.bind(bindArg);
+        std::ostringstream oss;
+        oss << "SELECT c FROM cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN cluster_type c_type ON c.cluster_type_id = c_type.id INNER JOIN artist a ON t_a_l.artist_id = a.id INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id";
 
-	Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> queryRes = query;
+        where.And(WhereClause("a.id = ?")).bind(getId().toString());
+        {
+            WhereClause clusterClause;
+            for (auto clusterType : clusterTypes)
+                clusterClause.Or(WhereClause("c_type.id = ?")).bind(clusterType->getId().toString());
 
-	std::map<ClusterTypeId, std::vector<Cluster::pointer>> clustersByType;
-	for (Cluster::pointer cluster : queryRes)
-	{
-		if (clustersByType[cluster->getType()->getId()].size() < size)
-			clustersByType[cluster->getType()->getId()].push_back(cluster);
-	}
+            where.And(clusterClause);
+        }
+        oss << " " << where.get();
+        oss << "GROUP BY c.id ORDER BY COUNT(DISTINCT c.id) DESC";
 
-	std::vector<std::vector<Cluster::pointer>> res;
-	for (const auto& [clusterTypeId, clusters] : clustersByType)
-		res.push_back(clusters);
+        Wt::Dbo::Query<Wt::Dbo::ptr<Cluster>> query = session()->query<Wt::Dbo::ptr<Cluster>>(oss.str());
 
-	return res;
-}
+        for (const std::string& bindArg : where.getBindArgs())
+            query.bind(bindArg);
 
-void
-Artist::setSortName(const std::string& sortName)
-{
-	_sortName = std::string(sortName, 0 , _maxNameLength);
-}
+        Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> queryRes = query;
+
+        std::map<ClusterTypeId, std::vector<Cluster::pointer>> clustersByType;
+        for (Cluster::pointer cluster : queryRes)
+        {
+            if (clustersByType[cluster->getType()->getId()].size() < size)
+                clustersByType[cluster->getType()->getId()].push_back(cluster);
+        }
+
+        std::vector<std::vector<Cluster::pointer>> res;
+        for (const auto& [clusterTypeId, clusters] : clustersByType)
+            res.push_back(clusters);
+
+        return res;
+    }
+
+    void Artist::setSortName(const std::string& sortName)
+    {
+        _sortName = std::string(sortName, 0, _maxNameLength);
+    }
 
 } // namespace Database
diff --git a/src/libs/services/database/impl/Db.cpp b/src/libs/services/database/impl/Db.cpp
index bcac0eaa..c2179165 100644
--- a/src/libs/services/database/impl/Db.cpp
+++ b/src/libs/services/database/impl/Db.cpp
@@ -40,13 +40,25 @@ namespace Database
                 prepare();
             }
 
+            Connection(const Connection& other)
+                : Wt::Dbo::backend::Sqlite3{ other }
+                , _dbPath{ other._dbPath }
+            {
+                prepare();
+            }
+
+            ~Connection()
+            {
+                // make use of per-connection usage stats to optimize
+                optimize();
+            }
+
         private:
-            Connection(const Connection&) = delete;
             Connection& operator=(const Connection&) = delete;
 
             std::unique_ptr<SqlConnection> clone() const override
             {
-                return std::make_unique<Connection>(_dbPath);
+                return std::make_unique<Connection>(*this);
             }
 
             void prepare()
@@ -54,10 +66,17 @@ namespace Database
                 LMS_LOG(DB, DEBUG) << "Setting per-connection settings...";
                 executeSql("pragma journal_mode=WAL");
                 executeSql("pragma synchronous=normal");
-                executeSql("pragma analysis_limit=1000"); // to help make analyze command faster
+                executeSql("pragma analysis_limit=2000"); // to help make analyze command faster, 1000 does not seem to be enough to speed up all queries
                 LMS_LOG(DB, DEBUG) << "Setting per-connection settings done!";
             }
 
+            void optimize()
+            {
+                LMS_LOG(DB, DEBUG) << "connection close: Running pragma optimize...";
+                executeSql("pragma optimize");
+                LMS_LOG(DB, DEBUG) << "connection close: pragma optimize complete";
+            }
+
             std::filesystem::path _dbPath;
         };
     }
@@ -68,7 +87,7 @@ namespace Database
         LMS_LOG(DB, INFO) << "Creating connection pool on file " << dbPath.string();
 
         auto connection{ std::make_unique<Connection>(dbPath.string()) };
-        //	connection->setProperty("show-queries", "true");
+        // connection->setProperty("show-queries", "true");
 
         auto connectionPool{ std::make_unique<Wt::Dbo::FixedSqlConnectionPool>(std::move(connection), connectionCount) };
         connectionPool->setTimeout(std::chrono::seconds{ 10 });
diff --git a/src/libs/services/database/impl/Listen.cpp b/src/libs/services/database/impl/Listen.cpp
index d77ef827..d7af57d0 100644
--- a/src/libs/services/database/impl/Listen.cpp
+++ b/src/libs/services/database/impl/Listen.cpp
@@ -29,14 +29,14 @@ namespace
 {
     using namespace Database;
 
-    Wt::Dbo::Query<ArtistId> createArtistsQuery(Wt::Dbo::Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType)
+    Wt::Dbo::Query<ArtistId> createArtistsQuery(Wt::Dbo::Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType)
     {
         auto query{ session.query<ArtistId>("SELECT a.id from artist a")
                         .join("track t ON t.id = t_a_l.track_id")
                         .join("track_artist_link t_a_l ON t_a_l.artist_id = a.id")
                         .join("listen l ON l.track_id = t.id")
                         .where("l.user_id = ?").bind(userId)
-                        .where("l.scrobbler = ?").bind(scrobbler) };
+                        .where("l.backend = ?").bind(backend) };
 
         if (linkType)
             query.where("t_a_l.type = ?").bind(*linkType);
@@ -66,13 +66,13 @@ namespace
         return query;
     }
 
-    Wt::Dbo::Query<ReleaseId> createReleasesQuery(Wt::Dbo::Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds)
+    Wt::Dbo::Query<ReleaseId> createReleasesQuery(Wt::Dbo::Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds)
     {
         auto query{ session.query<ReleaseId>("SELECT r.id from release r")
                         .join("track t ON t.release_id = r.id")
                         .join("listen l ON l.track_id = t.id")
                         .where("l.user_id = ?").bind(userId)
-                        .where("l.scrobbler = ?").bind(scrobbler) };
+                        .where("l.backend = ?").bind(backend) };
 
         if (!clusterIds.empty())
         {
@@ -98,12 +98,12 @@ namespace
         return query;
     }
 
-    Wt::Dbo::Query<TrackId> createTracksQuery(Wt::Dbo::Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds)
+    Wt::Dbo::Query<TrackId> createTracksQuery(Wt::Dbo::Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds)
     {
         auto query{ session.query<TrackId>("SELECT t.id from track t")
                     .join("listen l ON l.track_id = t.id")
                     .where("l.user_id = ?").bind(userId)
-                    .where("l.scrobbler = ?").bind(scrobbler) };
+                    .where("l.backend = ?").bind(backend) };
 
         if (!clusterIds.empty())
         {
@@ -131,16 +131,17 @@ namespace
 
 namespace Database
 {
-    Listen::Listen(ObjectPtr<User> user, ObjectPtr<Track> track, Scrobbler scrobbler, const Wt::WDateTime& dateTime)
+    Listen::Listen(ObjectPtr<User> user, ObjectPtr<Track> track, ScrobblingBackend backend, const Wt::WDateTime& dateTime)
         : _dateTime{ Wt::WDateTime::fromTime_t(dateTime.toTime_t()) }
-        , _scrobbler{ scrobbler }
+        , _backend{ backend }
         , _user{ getDboPtr(user) }
         , _track{ getDboPtr(track) }
     {}
 
-    Listen::pointer Listen::create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track, Scrobbler scrobbler, const Wt::WDateTime& dateTime)
+    Listen::pointer Listen::create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track, ScrobblingBackend backend, const Wt::WDateTime& dateTime)
     {
-        return session.getDboSession().add(std::unique_ptr<Listen> {new Listen{ user, track, scrobbler, dateTime }});
+        session.checkUniqueLocked();
+        return session.getDboSession().add(std::unique_ptr<Listen> {new Listen{ user, track, backend, dateTime }});
     }
 
     std::size_t Listen::getCount(Session& session)
@@ -165,30 +166,31 @@ namespace Database
         if (parameters.user.isValid())
             query.where("user_id = ?").bind(parameters.user);
 
-        if (parameters.scrobbler)
-            query.where("scrobbler = ?").bind(*parameters.scrobbler);
+        if (parameters.backend)
+            query.where("backend = ?").bind(*parameters.backend);
 
-        if (parameters.scrobblingState)
-            query.where("scrobbling_state = ?").bind(*parameters.scrobblingState);
+        if (parameters.syncState)
+            query.where("sync_state = ?").bind(*parameters.syncState);
 
         return Utils::execQuery(query, parameters.range);
     }
 
-    Listen::pointer Listen::find(Session& session, UserId userId, TrackId trackId, Scrobbler scrobbler, const Wt::WDateTime& dateTime)
+    Listen::pointer Listen::find(Session& session, UserId userId, TrackId trackId, ScrobblingBackend backend, const Wt::WDateTime& dateTime)
     {
         session.checkSharedLocked();
 
         return session.getDboSession().find<Listen>()
             .where("user_id = ?").bind(userId)
             .where("track_id = ?").bind(trackId)
-            .where("scrobbler = ?").bind(scrobbler)
+            .where("backend = ?").bind(backend)
             .where("date_time = ?").bind(Wt::WDateTime::fromTime_t(dateTime.toTime_t()))
             .resultValue();
     }
 
-    RangeResults<ArtistId> Listen::getTopArtists(Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, Range range)
+    RangeResults<ArtistId> Listen::getTopArtists(Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, Range range)
     {
-        auto query{ createArtistsQuery(session.getDboSession(), userId, scrobbler, clusterIds, linkType) };
+        session.checkSharedLocked();
+        auto query{ createArtistsQuery(session.getDboSession(), userId, backend, clusterIds, linkType) };
 
         auto collection{ query
             .orderBy("COUNT(a.id) DESC")
@@ -197,72 +199,107 @@ namespace Database
         return Utils::execQuery(query, range);
     }
 
-    RangeResults<ReleaseId> Listen::getTopReleases(Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, Range range)
+    RangeResults<ReleaseId> Listen::getTopReleases(Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, Range range)
     {
-        auto query{ createReleasesQuery(session.getDboSession(), userId, scrobbler, clusterIds)
+        session.checkSharedLocked();
+        auto query{ createReleasesQuery(session.getDboSession(), userId, backend, clusterIds)
                         .orderBy("COUNT(r.id) DESC")
                         .groupBy("r.id") };
 
         return Utils::execQuery(query, range);
     }
 
-    RangeResults<TrackId> Listen::getTopTracks(Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, Range range)
+    RangeResults<TrackId> Listen::getTopTracks(Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, Range range)
     {
-        auto query{ createTracksQuery(session.getDboSession(), userId, scrobbler, clusterIds)
+        session.checkSharedLocked();
+        auto query{ createTracksQuery(session.getDboSession(), userId, backend, clusterIds)
                         .orderBy("COUNT(t.id) DESC")
                         .groupBy("t.id") };
 
         return Utils::execQuery(query, range);
     }
 
-    RangeResults<ArtistId> Listen::getRecentArtists(Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, Range range)
+    RangeResults<ArtistId> Listen::getRecentArtists(Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, Range range)
     {
-        auto query{ createArtistsQuery(session.getDboSession(), userId, scrobbler, clusterIds, linkType)
+        session.checkSharedLocked();
+        auto query{ createArtistsQuery(session.getDboSession(), userId, backend, clusterIds, linkType)
                         .groupBy("a.id").having("l.date_time = MAX(l.date_time)")
                         .orderBy("l.date_time DESC") };
 
         return Utils::execQuery(query, range);
     }
 
-    RangeResults<ReleaseId> Listen::getRecentReleases(Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, Range range)
+    RangeResults<ReleaseId> Listen::getRecentReleases(Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, Range range)
     {
-        auto query{ createReleasesQuery(session.getDboSession(), userId, scrobbler, clusterIds)
+        session.checkSharedLocked();
+        auto query{ createReleasesQuery(session.getDboSession(), userId, backend, clusterIds)
                         .groupBy("r.id").having("l.date_time = MAX(l.date_time)")
                         .orderBy("l.date_time DESC") };
 
         return Utils::execQuery(query, range);
     }
 
-    RangeResults<TrackId> Listen::getRecentTracks(Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, Range range)
+    RangeResults<TrackId> Listen::getRecentTracks(Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, Range range)
     {
-        auto query{ createTracksQuery(session.getDboSession(), userId, scrobbler, clusterIds)
+        session.checkSharedLocked();
+        auto query{ createTracksQuery(session.getDboSession(), userId, backend, clusterIds)
                         .groupBy("t.id").having("l.date_time = MAX(l.date_time)")
                         .orderBy("l.date_time DESC") };
 
         return Utils::execQuery(query, range);
     }
 
-    Listen::pointer Listen::getMostRecentListen(Session& session, UserId userId, Scrobbler scrobbler, ReleaseId releaseId)
+    std::size_t Listen::getCount(Session& session, UserId userId, ScrobblingBackend backend, TrackId trackId)
     {
+        session.checkSharedLocked();
+
+        return session.getDboSession().query<int>("SELECT COUNT(*) from listen l")
+            .where("l.track_id = ?").bind(trackId)
+            .where("l.user_id = ?").bind(userId)
+            .where("l.backend = ?").bind(backend)
+            .resultValue();
+    }
+
+    std::size_t Listen::getCount(Session& session, UserId userId, ScrobblingBackend backend, ReleaseId releaseId)
+    {
+        session.checkSharedLocked();
+
+        return session.getDboSession().query<int>("SELECT IFNULL(MIN(count_result), 0)"
+            " FROM ("
+            " SELECT COUNT(l.track_id) AS count_result"
+            " FROM track t"
+            " LEFT JOIN listen l ON t.id = l.track_id AND l.backend = ? AND l.user_id = ?"
+            " WHERE t.release_id = ?"
+            " GROUP BY t.id)")
+            .bind(backend)
+            .bind(userId)
+            .bind(releaseId)
+            .resultValue();
+    }
+
+    Listen::pointer Listen::getMostRecentListen(Session& session, UserId userId, ScrobblingBackend backend, ReleaseId releaseId)
+    {
+        session.checkSharedLocked();
+
         // TODO not pending remove?
         return session.getDboSession().query<Wt::Dbo::ptr<Listen>>("SELECT l from listen l")
             .join("track t ON l.track_id = t.id")
             .where("t.release_id = ?").bind(releaseId)
             .where("l.user_id = ?").bind(userId)
-            .where("l.scrobbler = ?").bind(scrobbler)
+            .where("l.backend = ?").bind(backend)
             .orderBy("l.date_time DESC")
             .limit(1)
             .resultValue();
     }
 
-    Listen::pointer Listen::getMostRecentListen(Session& session, UserId userId, Scrobbler scrobbler, TrackId trackId)
+    Listen::pointer Listen::getMostRecentListen(Session& session, UserId userId, ScrobblingBackend backend, TrackId trackId)
     {
+        session.checkSharedLocked();
         // TODO not pending remove?
         return session.getDboSession().query<Wt::Dbo::ptr<Listen>>("SELECT l from listen l")
-            .join("track t ON track_id = t.id")
-            .where("t.id = ?").bind(trackId)
+            .where("l.track_id = ?").bind(trackId)
             .where("l.user_id = ?").bind(userId)
-            .where("l.scrobbler = ?").bind(scrobbler)
+            .where("l.backend = ?").bind(backend)
             .orderBy("l.date_time DESC")
             .limit(1)
             .resultValue();
diff --git a/src/libs/services/database/impl/Migration.cpp b/src/libs/services/database/impl/Migration.cpp
index 6c11b887..da002ba0 100644
--- a/src/libs/services/database/impl/Migration.cpp
+++ b/src/libs/services/database/impl/Migration.cpp
@@ -72,414 +72,6 @@ namespace Database::Migration
         Db& _db;
     };
 
-    static std::string dateTimeToDbFormat(const Wt::WDateTime& dateTime)
-    {
-        return dateTime.toString("yyyy'-'MM'-'dd'T'hh':'mm':'ss'.000'", false).toUTF8();
-    }
-
-    static void migrateFromV5(Session& session)
-    {
-        session.getDboSession().execute("DELETE FROM auth_token"); // format has changed
-    }
-
-    static void migrateFromV6(Session& session)
-    {
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-
-    static void migrateFromV7(Session& session)
-    {
-        session.getDboSession().execute("DROP TABLE similarity_settings");
-        session.getDboSession().execute("DROP TABLE similarity_settings_feature");
-        session.getDboSession().execute("ALTER TABLE scan_settings ADD similarity_engine_type INTEGER NOT NULL DEFAULT(" + std::to_string(static_cast<int>(ScanSettings::RecommendationEngineType::Clusters)) + ")");
-    }
-
-    static void migrateFromV8(Session& session)
-    {
-        // Better cover handling, need to rescan the whole files
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV9(Session& session)
-    {
-        session.getDboSession().execute(R"(
-CREATE TABLE IF NOT EXISTS "track_bookmark" (
-    "id" integer primary key autoincrement,
-    "version" integer not null,
-    "offset" integer,
-    "comment" text not null,
-    "track_id" bigint,
-    "user_id" bigint,
-    constraint "fk_track_bookmark_track" foreign key ("track_id") references "track" ("id") on delete cascade deferrable initially deferred,
-    constraint "fk_track_bookmark_user" foreign key ("user_id") references "user" ("id") on delete cascade deferrable initially deferred
-);)");
-    }
-
-    static void migrateFromV10(Session& session)
-    {
-        ScanSettings::get(session).modify()->addAudioFileExtension(".m4b");
-        ScanSettings::get(session).modify()->addAudioFileExtension(".alac");
-    }
-
-    static void migrateFromV11(Session& session)
-    {
-        // Sanitize bad MBID, need to rescan the whole files
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV12(Session& session)
-    {
-        // Artist and release that have a badly parsed name but a MBID had no chance to updat the name
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV13(Session& session)
-    {
-        // Always store UUID in lower case + better WMA parsing
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV14(Session& session)
-    {
-        // SortName now set from metadata
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV15(Session& session)
-    {
-        session.getDboSession().execute("ALTER TABLE user ADD ui_theme INTEGER NOT NULL DEFAULT(" + std::to_string(static_cast<int>(User::defaultUITheme)) + ")");
-    }
-
-    static void migrateFromV16(Session& session)
-    {
-        session.getDboSession().execute("ALTER TABLE track ADD total_disc INTEGER NOT NULL DEFAULT(0)");
-        session.getDboSession().execute("ALTER TABLE track ADD total_track INTEGER NOT NULL DEFAULT(0)");
-
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV17(Session& session)
-    {
-        // Drop colums total_disc/total_track from release
-        session.getDboSession().execute(R"(
-CREATE TABLE "release_backup" (
-  "id" integer primary key autoincrement,
-  "version" integer not null,
-  "name" text not null,
-  "mbid" text not null
-))");
-        session.getDboSession().execute("INSERT INTO release_backup SELECT id,version,name,mbid FROM release");
-        session.getDboSession().execute("DROP TABLE release");
-        session.getDboSession().execute("ALTER TABLE release_backup RENAME TO release");
-
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV18(Session& session)
-    {
-        session.getDboSession().execute(R"(
-CREATE TABLE IF NOT EXISTS "subsonic_settings" (
-  "id" integer primary key autoincrement,
-  "version" integer not null,
-  "api_enabled" boolean not null,
-  "artist_list_mode" integer not null
-))");
-    }
-
-    static void migrateFromV19(Session& session)
-    {
-        session.getDboSession().execute(R"(
-CREATE TABLE "user_backup" (
-  "id" integer primary key autoincrement,
-  "version" integer not null,
-  "type" integer not null,
-  "login_name" text not null,
-  "password_salt" text not null,
-  "password_hash" text not null,
-  "last_login" text,
-  "subsonic_transcode_enable" boolean not null,
-  "subsonic_transcode_format" integer not null,
-  "subsonic_transcode_bitrate" integer not null,
-  "subsonic_artist_list_mode" integer not null,
-  "ui_theme" integer not null,
-  "cur_playing_track_pos" integer not null,
-  "repeat_all" boolean not null,
-  "radio" boolean not null
-))");
-        session.getDboSession().execute(std::string{ "INSERT INTO user_backup SELECT id, version, type, login_name, password_salt, password_hash, last_login, " }
-            + "1" // default enable transcode
-            + ", " + std::to_string(static_cast<int>(User::defaultSubsonicTranscodeFormat))
-            + ", " + std::to_string(User::defaultSubsonicTranscodeBitrate)
-            + ", " + std::to_string(static_cast<int>(User::defaultSubsonicArtistListMode))
-            + ", ui_theme, cur_playing_track_pos, repeat_all, radio FROM user");
-        session.getDboSession().execute("DROP TABLE user");
-        session.getDboSession().execute("ALTER TABLE user_backup RENAME TO user");
-    }
-
-    static void migrateFromV20(Session& session)
-    {
-        session.getDboSession().execute("DROP TABLE subsonic_settings");
-    }
-
-    static void migrateFromV21(Session& session)
-    {
-        session.getDboSession().execute("ALTER TABLE track ADD track_replay_gain REAL");
-        session.getDboSession().execute("ALTER TABLE track ADD release_replay_gain REAL");
-
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV22(Session& session)
-    {
-        session.getDboSession().execute("ALTER TABLE track ADD disc_subtitle TEXT NOT NULL DEFAULT ''");
-
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV23(Session& session)
-    {
-        // Better cover detection
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV24(Session& session)
-    {
-        // User's AuthMode
-        session.getDboSession().execute("ALTER TABLE user ADD auth_mode INTEGER NOT NULL DEFAULT(" + std::to_string(static_cast<int>(/*User::defaultAuthMode*/0)) + ")");
-    }
-
-    static void migrateFromV25(Session& session)
-    {
-        // Better cover detection
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV26(Session& session)
-    {
-        // Composer, mixer, etc. support
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV27(Session& session)
-    {
-        // Composer, mixer, etc. support, now fallback on MBID tagged entries as there is no mean to provide MBID by tags for these kinf od artists
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV28(Session& session)
-    {
-        // Drop Auth mode
-        session.getDboSession().execute(R"(
-CREATE TABLE "user_backup" (
-  "id" integer primary key autoincrement,
-  "version" integer not null,
-  "type" integer not null,
-  "login_name" text not null,
-  "password_salt" text not null,
-  "password_hash" text not null,
-  "last_login" text,
-  "subsonic_transcode_enable" boolean not null,
-  "subsonic_transcode_format" integer not null,
-  "subsonic_transcode_bitrate" integer not null,
-  "subsonic_artist_list_mode" integer not null,
-  "ui_theme" integer not null,
-  "cur_playing_track_pos" integer not null,
-  "repeat_all" boolean not null,
-  "radio" boolean not null
-))");
-        session.getDboSession().execute("INSERT INTO user_backup SELECT id, version, type, login_name, password_salt, password_hash, last_login, subsonic_transcode_enable, subsonic_transcode_format, subsonic_transcode_bitrate, subsonic_artist_list_mode, ui_theme, cur_playing_track_pos, repeat_all, radio FROM user");
-        session.getDboSession().execute("DROP TABLE user");
-        session.getDboSession().execute("ALTER TABLE user_backup RENAME TO user");
-    }
-
-    static void migrateFromV29(Session& session)
-    {
-        session.getDboSession().execute("ALTER TABLE tracklist_entry ADD date_time TEXT");
-        session.getDboSession().execute("ALTER TABLE user ADD listenbrainz_token TEXT");
-        session.getDboSession().execute("ALTER TABLE user ADD scrobbler INTEGER NOT NULL DEFAULT(" + std::to_string(static_cast<int>(User::defaultScrobbler)) + ")");
-        session.getDboSession().execute("ALTER TABLE track ADD recording_mbid TEXT");
-
-        session.getDboSession().execute("DELETE from tracklist WHERE name = ?").bind("__played_tracks__");
-
-        // MBID changes
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV30(Session& session)
-    {
-        // drop "year" and "original_year" (rescan needed to convert them into dates)
-        session.getDboSession().execute(R"(
-CREATE TABLE "track_backup" (
-  "id" integer primary key autoincrement,
-  "version" integer not null,
-  "scan_version" integer not null,
-  "track_number" integer not null,
-  "disc_number" integer not null,
-  "name" text not null,
-  "duration" integer,
-  "date" integer text,
-  "original_date" integer text,
-  "file_path" text not null,
-  "file_last_write" text,
-  "file_added" text,
-  "has_cover" boolean not null,
-  "mbid" text not null,
-  "copyright" text not null,
-  "copyright_url" text not null,
-  "release_id" bigint, total_disc INTEGER NOT NULL DEFAULT(0), total_track INTEGER NOT NULL DEFAULT(0), track_replay_gain REAL, release_replay_gain REAL, disc_subtitle TEXT NOT NULL DEFAULT '', recording_mbid TEXT,
-  constraint "fk_track_release" foreign key ("release_id") references "release" ("id") on delete cascade deferrable initially deferred
-))");
-        session.getDboSession().execute("INSERT INTO track_backup SELECT id, version, scan_version, track_number, disc_number, name, duration, \"1900-01-01\", \"1900-01-01\", file_path, file_last_write, file_added, has_cover, mbid, copyright, copyright_url, release_id, total_disc, total_track, track_replay_gain, release_replay_gain, disc_subtitle, recording_mbid FROM track");
-        session.getDboSession().execute("DROP TABLE track");
-        session.getDboSession().execute("ALTER TABLE track_backup RENAME TO track");
-
-        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
-        ScanSettings::get(session).modify()->incScanVersion();
-    }
-
-    static void migrateFromV31(Session& session)
-    {
-        // new star system, using dedicated entries per scrobbler and date time
-        session.getDboSession().execute(R"(
-CREATE TABLE "starred_artist" (
-  "id" integer primary key autoincrement,
-  "version" integer not null,
-  "scrobbler" integer not null,
-  "date_time" text,
-  "artist_id" bigint,
-  "user_id" bigint,
-  constraint "fk_starred_artist_artist" foreign key ("artist_id") references "artist" ("id") on delete cascade deferrable initially deferred,
-  constraint "fk_starred_artist_user" foreign key ("user_id") references "user" ("id") on delete cascade deferrable initially deferred
-))");
-
-        session.getDboSession().execute(R"(
-CREATE TABLE "starred_release" (
-  "id" integer primary key autoincrement,
-  "version" integer not null,
-  "scrobbler" integer not null,
-  "date_time" text,
-  "release_id" bigint,
-  "user_id" bigint,
-  constraint "fk_starred_release_release" foreign key ("release_id") references "release" ("id") on delete cascade deferrable initially deferred,
-  constraint "fk_starred_release_user" foreign key ("user_id") references "user" ("id") on delete cascade deferrable initially deferred
-))");
-
-        session.getDboSession().execute(R"(
-CREATE TABLE "starred_track" (
-  "id" integer primary key autoincrement,
-  "version" integer not null,
-  "scrobbler" integer not null,
-  "date_time" text,
-  "track_id" bigint,
-  "user_id" bigint,
-  constraint "fk_starred_track_track" foreign key ("track_id") references "track" ("id") on delete cascade deferrable initially deferred,
-  constraint "fk_starred_track_user" foreign key ("user_id") references "user" ("id") on delete cascade deferrable initially deferred
-))");
-
-        // Can't migrate using class mapping as mapping may evolve in the future
-
-        // use time_t to avoid rounding issues later
-        const std::string now{ dateTimeToDbFormat(Wt::WDateTime::fromTime_t(Wt::WDateTime::currentDateTime().toTime_t())) };
-
-        std::map<IdType::ValueType, Scrobbler> userScrobblers;
-        auto getScrobbler{ [&](IdType::ValueType userId)
-        {
-            auto itScrobbler {userScrobblers.find(userId)};
-            if (itScrobbler != std::cend(userScrobblers))
-                return itScrobbler->second;
-
-            auto query {session.getDboSession().query<Scrobbler>("SELECT scrobbler FROM user WHERE id = ?").bind(userId)};
-            [[maybe_unused]] auto [itInserted, inserted] {userScrobblers.emplace(userId, query.resultValue())};
-            assert(inserted);
-            return itInserted->second;
-        } };
-
-        auto migrateStarEntries{ [&session, &getScrobbler, &now](const std::string& colName, const std::string& oldTableName, const std::string& newTableName)
-        {
-            using UserIdObjectId = std::tuple<IdType::ValueType /* userId */, IdType::ValueType /* entryId */>;
-
-            std::vector<UserIdObjectId> starredEntries;
-            auto query {session.getDboSession().query<UserIdObjectId>("SELECT user_id, " + colName + " from " + oldTableName)};
-            auto results {query.resultList()};
-
-            LMS_LOG(DB, INFO) << "Found " << results.size() << " " << colName << " to migrate";
-
-            for (const auto& [userId, entryId] : results)
-            {
-                session.getDboSession().execute("INSERT INTO " + newTableName + " ('version', 'scrobbler', 'date_time', '" + colName + "', 'user_id') VALUES (?, ?, ?, ?, ?)")
-                    .bind(0)
-                    .bind(getScrobbler(userId))
-                    .bind(now)
-                    .bind(entryId)
-                    .bind(userId);
-            }
-
-            session.getDboSession().execute("DROP TABLE " + oldTableName);
-        } };
-
-        migrateStarEntries("artist_id", "user_artist_starred", "starred_artist");
-        migrateStarEntries("release_id", "user_release_starred", "starred_release");
-        migrateStarEntries("track_id", "user_track_starred", "starred_track");
-
-        // new listen system, no longer using tracklists
-        session.getDboSession().execute(R"(
-CREATE TABLE "listen" (
-  "id" integer primary key autoincrement,
-  "version" integer not null,
-  "date_time" text,
-  "scrobbler" integer not null,
-  "scrobbling_state" integer not null,
-  "track_id" bigint,
-  "user_id" bigint,
-  constraint "fk_listen_track" foreign key ("track_id") references "track" ("id") on delete cascade deferrable initially deferred,
-  constraint "fk_listen_user" foreign key ("user_id") references "user" ("id") on delete cascade deferrable initially deferred
-))");
-
-        auto migrateListens{ [&session](const std::string& trackListName, Scrobbler scrobbler)
-        {
-            using UserIdObjectId = std::tuple<IdType::ValueType /* userId */, IdType::ValueType /* trackId */, Wt::WDateTime>;
-
-            std::vector<UserIdObjectId> listens;
-            auto query {session.getDboSession().query<UserIdObjectId>("SELECT t_l.user_id, t_l_e.track_id, t_l_e.date_time FROM tracklist t_l")
-                                                    .join("tracklist_entry t_l_e ON t_l_e.tracklist_id = t_l.id")
-                                                    .where("t_l.name = ?").bind(trackListName)};
-            auto results {query.resultList()};
-            listens.reserve(results.size());
-
-            LMS_LOG(DB, INFO) << "Found " << results.size() << " listens in " << trackListName;
-
-            for (const auto& [userId, trackId, dateTime] : results)
-            {
-                session.getDboSession().execute("INSERT INTO listen ('version', 'date_time', 'scrobbler', 'scrobbling_state', 'track_id', 'user_id') VALUES (?, ?, ?, ?, ?, ?)")
-                    .bind(0)
-                    .bind(dateTimeToDbFormat(dateTime))
-                    .bind(scrobbler)
-                    .bind(ScrobblingState::Synchronized) // consider sync is done to avoid duplicate submissions
-                    .bind(trackId)
-                    .bind(userId);
-            }
-        } };
-
-        migrateListens("__scrobbler_internal_history__", Scrobbler::Internal);
-        migrateListens("__scrobbler_listenbrainz_history__", Scrobbler::ListenBrainz);
-    }
-
     static void migrateFromV32(Session& session)
     {
         ScanSettings::get(session).modify()->addAudioFileExtension(".wv");
@@ -605,6 +197,33 @@ CREATE TABLE IF NOT EXISTS "track_backup" (
         session.getDboSession().execute("ALTER TABLE user DROP COLUMN subsonic_transcode_enable");
     }
 
+    static void migrateFromV42(Session& session)
+    {
+        session.getDboSession().execute("DROP INDEX IF EXISTS listen_scrobbler_idx");
+        session.getDboSession().execute("DROP INDEX IF EXISTS listen_user_scrobbler_idx");
+        session.getDboSession().execute("DROP INDEX IF EXISTS listen_user_track_scrobbler_date_time_idx");
+        session.getDboSession().execute("DROP INDEX IF EXISTS starred_artist_user_scrobbler_idx");
+        session.getDboSession().execute("DROP INDEX IF EXISTS starred_artist_artist_user_scrobbler_idx");
+        session.getDboSession().execute("DROP INDEX IF EXISTS starred_release_user_scrobbler_idx");
+        session.getDboSession().execute("DROP INDEX IF EXISTS starred_release_release_user_scrobbler_idx");
+        session.getDboSession().execute("DROP INDEX IF EXISTS starred_track_user_scrobbler_idx");
+        session.getDboSession().execute("DROP INDEX IF EXISTS starred_track_track_user_scrobbler_idx");
+
+        // New feedback service that now handles the star/unstar stuff (that was previously handled by the scrobbling service)
+        session.getDboSession().execute("ALTER TABLE user RENAME COLUMN scrobbler TO scrobbling_backend");
+        session.getDboSession().execute("ALTER TABLE user ADD feedback_backend INTEGER");
+        session.getDboSession().execute("ALTER TABLE listen RENAME COLUMN scrobbler TO backend");
+        session.getDboSession().execute("ALTER TABLE listen RENAME COLUMN scrobbling_state TO sync_state");
+        session.getDboSession().execute("ALTER TABLE starred_artist RENAME COLUMN scrobbler TO backend");
+        session.getDboSession().execute("ALTER TABLE starred_artist RENAME COLUMN scrobbling_state TO sync_state");
+        session.getDboSession().execute("ALTER TABLE starred_release RENAME COLUMN scrobbler TO backend");
+        session.getDboSession().execute("ALTER TABLE starred_release RENAME COLUMN scrobbling_state TO sync_state");
+        session.getDboSession().execute("ALTER TABLE starred_track RENAME COLUMN scrobbler TO backend");
+        session.getDboSession().execute("ALTER TABLE starred_track RENAME COLUMN scrobbling_state TO sync_state");
+        
+        session.getDboSession().execute("UPDATE user SET feedback_backend = scrobbling_backend");
+    }
+
     void doDbMigration(Session& session)
     {
         static const std::string outdatedMsg{ "Outdated database, please rebuild it (delete the .db file and restart)" };
@@ -615,33 +234,6 @@ CREATE TABLE IF NOT EXISTS "track_backup" (
 
         const std::map<unsigned, MigrationFunction> migrationFunctions
         {
-            {5, migrateFromV5},
-            {6, migrateFromV6},
-            {7, migrateFromV7},
-            {8, migrateFromV8},
-            {9, migrateFromV9},
-            {10, migrateFromV10},
-            {11, migrateFromV11},
-            {12, migrateFromV12},
-            {13, migrateFromV13},
-            {14, migrateFromV14},
-            {15, migrateFromV15},
-            {16, migrateFromV16},
-            {17, migrateFromV17},
-            {18, migrateFromV18},
-            {19, migrateFromV19},
-            {20, migrateFromV20},
-            {21, migrateFromV21},
-            {22, migrateFromV22},
-            {23, migrateFromV23},
-            {24, migrateFromV24},
-            {25, migrateFromV25},
-            {26, migrateFromV26},
-            {27, migrateFromV27},
-            {28, migrateFromV28},
-            {29, migrateFromV29},
-            {30, migrateFromV30},
-            {31, migrateFromV31},
             {32, migrateFromV32},
             {33, migrateFromV33},
             {34, migrateFromV34},
@@ -652,6 +244,7 @@ CREATE TABLE IF NOT EXISTS "track_backup" (
             {39, migrateFromV39},
             {40, migrateFromV40},
             {41, migrateFromV41},
+            {42, migrateFromV42},
         };
 
         {
diff --git a/src/libs/services/database/impl/Migration.hpp b/src/libs/services/database/impl/Migration.hpp
index 68a70ade..55b1e679 100644
--- a/src/libs/services/database/impl/Migration.hpp
+++ b/src/libs/services/database/impl/Migration.hpp
@@ -26,7 +26,7 @@ namespace Database
     class Session;
 
     using Version = std::size_t;
-    static constexpr Version LMS_DATABASE_VERSION{ 42 };
+    static constexpr Version LMS_DATABASE_VERSION{ 43 };
     class VersionInfo
     {
     public:
diff --git a/src/libs/services/database/impl/Release.cpp b/src/libs/services/database/impl/Release.cpp
index 109c24b7..8021dc98 100644
--- a/src/libs/services/database/impl/Release.cpp
+++ b/src/libs/services/database/impl/Release.cpp
@@ -34,147 +34,170 @@
 
 namespace Database
 {
-
-    Wt::Dbo::Query<ReleaseId> createQuery(Session& session, const Release::FindParameters& params)
+    namespace
     {
-        auto query{ session.getDboSession().query<ReleaseId>("SELECT DISTINCT r.id from release r") };
-
-        if (params.sortMethod == ReleaseSortMethod::LastWritten
-            || params.sortMethod == ReleaseSortMethod::Date
-            || params.sortMethod == ReleaseSortMethod::OriginalDate
-            || params.sortMethod == ReleaseSortMethod::OriginalDateDesc
-            || params.writtenAfter.isValid()
-            || params.dateRange
-            || params.artist.isValid())
+        template <typename ResultType>
+        Wt::Dbo::Query<ResultType> createQuery(Session& session, std::string_view itemToSelect, const Release::FindParameters& params)
         {
-            query.join("track t ON t.release_id = r.id");
-        }
+            auto query{ session.getDboSession().query<ResultType>("SELECT DISTINCT " + std::string{ itemToSelect } + " from release r") };
 
-        if (params.writtenAfter.isValid())
-            query.where("t.file_last_write > ?").bind(params.writtenAfter);
-
-        if (params.dateRange)
-        {
-            query.where("t.date >= ?").bind(params.dateRange->begin);
-            query.where("t.date <= ?").bind(params.dateRange->end);
-        }
-
-        for (std::string_view keyword : params.keywords)
-            query.where("r.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'").bind("%" + Utils::escapeLikeKeyword(keyword) + "%");
-
-        if (params.starringUser.isValid())
-        {
-            assert(params.scrobbler);
-            query.join("starred_release s_r ON s_r.release_id = r.id")
-                .where("s_r.user_id = ?").bind(params.starringUser)
-                .where("s_r.scrobbler = ?").bind(*params.scrobbler)
-                .where("s_r.scrobbling_state <> ?").bind(ScrobblingState::PendingRemove);
-        }
-
-        if (params.artist.isValid())
-        {
-            query.join("artist a ON a.id = t_a_l.artist_id")
-                .join("track_artist_link t_a_l ON t_a_l.track_id = t.id")
-                .where("a.id = ?").bind(params.artist);
-
-            if (!params.trackArtistLinkTypes.empty())
+            if (params.sortMethod == ReleaseSortMethod::LastWritten
+                || params.sortMethod == ReleaseSortMethod::Date
+                || params.sortMethod == ReleaseSortMethod::OriginalDate
+                || params.sortMethod == ReleaseSortMethod::OriginalDateDesc
+                || params.writtenAfter.isValid()
+                || params.dateRange
+                || params.artist.isValid()
+                || params.clusters.size() == 1)
             {
-                std::ostringstream oss;
-
-                bool first{ true };
-                for (TrackArtistLinkType linkType : params.trackArtistLinkTypes)
-                {
-                    if (!first)
-                        oss << " OR ";
-                    oss << "t_a_l.type = ?";
-                    query.bind(linkType);
-
-                    first = false;
-                }
-                query.where(oss.str());
+                query.join("track t ON t.release_id = r.id");
             }
 
-            if (!params.excludedTrackArtistLinkTypes.empty())
+            if (params.writtenAfter.isValid())
+                query.where("t.file_last_write > ?").bind(params.writtenAfter);
+
+            if (params.dateRange)
+            {
+                query.where("t.date >= ?").bind(params.dateRange->begin);
+                query.where("t.date <= ?").bind(params.dateRange->end);
+            }
+
+            for (std::string_view keyword : params.keywords)
+                query.where("r.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'").bind("%" + Utils::escapeLikeKeyword(keyword) + "%");
+
+            if (params.starringUser.isValid())
+            {
+                assert(params.feedbackBackend);
+                query.join("starred_release s_r ON s_r.release_id = r.id")
+                    .where("s_r.user_id = ?").bind(params.starringUser)
+                    .where("s_r.backend = ?").bind(*params.feedbackBackend)
+                    .where("s_r.sync_state <> ?").bind(SyncState::PendingRemove);
+            }
+
+            if (params.artist.isValid())
+            {
+                query.join("artist a ON a.id = t_a_l.artist_id")
+                    .join("track_artist_link t_a_l ON t_a_l.track_id = t.id")
+                    .where("a.id = ?").bind(params.artist);
+
+                if (!params.trackArtistLinkTypes.empty())
+                {
+                    std::ostringstream oss;
+
+                    bool first{ true };
+                    for (TrackArtistLinkType linkType : params.trackArtistLinkTypes)
+                    {
+                        if (!first)
+                            oss << " OR ";
+                        oss << "t_a_l.type = ?";
+                        query.bind(linkType);
+
+                        first = false;
+                    }
+                    query.where(oss.str());
+                }
+
+                if (!params.excludedTrackArtistLinkTypes.empty())
+                {
+                    std::ostringstream oss;
+                    oss << "r.id NOT IN (SELECT DISTINCT r.id FROM release r"
+                        " INNER JOIN artist a ON a.id = t_a_l.artist_id"
+                        " INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id"
+                        " INNER JOIN track t ON t.release_id = r.id"
+                        " WHERE (a.id = ? AND (";
+
+                    query.bind(params.artist);
+
+                    bool first{ true };
+                    for (const TrackArtistLinkType linkType : params.excludedTrackArtistLinkTypes)
+                    {
+                        if (!first)
+                            oss << " OR ";
+                        oss << "t_a_l.type = ?";
+                        query.bind(linkType);
+
+                        first = false;
+                    }
+                    oss << ")))";
+                    query.where(oss.str());
+                }
+            }
+
+            if (params.clusters.size() == 1)
+            {
+                query.join("track_cluster t_c ON t_c.track_id = t.id")
+                    .where("t_c.cluster_id = ?").bind(params.clusters.front());
+            }
+            else if (params.clusters.size() > 1)
             {
                 std::ostringstream oss;
-                oss << "r.id NOT IN (SELECT DISTINCT r.id FROM release r"
-                    " INNER JOIN artist a ON a.id = t_a_l.artist_id"
-                    " INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id"
+                oss << "r.id IN (SELECT DISTINCT r.id FROM release r"
                     " INNER JOIN track t ON t.release_id = r.id"
-                    " WHERE (a.id = ? AND (";
+                    " INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
 
-                query.bind(params.artist);
-
-                bool first{ true };
-                for (const TrackArtistLinkType linkType : params.excludedTrackArtistLinkTypes)
+                WhereClause clusterClause;
+                for (const ClusterId clusterId : params.clusters)
                 {
-                    if (!first)
-                        oss << " OR ";
-                    oss << "t_a_l.type = ?";
-                    query.bind(linkType);
-
-                    first = false;
+                    clusterClause.Or(WhereClause("t_c.cluster_id = ?"));
+                    query.bind(clusterId);
                 }
-                oss << ")))";
+
+                oss << " " << clusterClause.get();
+                oss << " GROUP BY t.id HAVING COUNT(*) = " << params.clusters.size() << ")";
+
                 query.where(oss.str());
             }
-        }
 
-        if (!params.clusters.empty())
-        {
-            std::ostringstream oss;
-            oss << "r.id IN (SELECT DISTINCT r.id FROM release r"
-                " INNER JOIN track t ON t.release_id = r.id"
-                " INNER JOIN cluster c ON c.id = t_c.cluster_id"
-                " INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
+            if (params.primaryType)
+                query.where("primary_type = ?").bind(*params.primaryType);
+            if (!params.secondaryTypes.empty())
+                query.where("secondary_type = ?").bind(params.secondaryTypes);
 
-            WhereClause clusterClause;
-            for (const ClusterId clusterId : params.clusters)
+            switch (params.sortMethod)
             {
-                clusterClause.Or(WhereClause("c.id = ?"));
-                query.bind(clusterId);
+            case ReleaseSortMethod::None:
+                break;
+            case ReleaseSortMethod::Name:
+                query.orderBy("r.name COLLATE NOCASE");
+                break;
+            case ReleaseSortMethod::Random:
+                query.orderBy("RANDOM()");
+                break;
+            case ReleaseSortMethod::LastWritten:
+                query.orderBy("t.file_last_write DESC");
+                break;
+            case ReleaseSortMethod::Date:
+                query.orderBy("t.date, r.name COLLATE NOCASE");
+                break;
+            case ReleaseSortMethod::OriginalDate:
+                query.orderBy("CASE WHEN t.original_date IS NULL THEN t.date ELSE t.original_date END, t.date, r.name COLLATE NOCASE");
+                break;
+            case ReleaseSortMethod::OriginalDateDesc:
+                query.orderBy("CASE WHEN t.original_date IS NULL THEN t.date ELSE t.original_date END DESC, t.date, r.name COLLATE NOCASE");
+                break;
+            case ReleaseSortMethod::StarredDateDesc:
+                assert(params.starringUser.isValid());
+                query.orderBy("s_r.date_time DESC");
+                break;
             }
 
-            oss << " " << clusterClause.get();
-            oss << " GROUP BY t.id HAVING COUNT(*) = " << params.clusters.size() << ")";
-
-            query.where(oss.str());
+            return query;
         }
 
-        if (params.primaryType)
-            query.where("primary_type = ?").bind(*params.primaryType);
-        if (!params.secondaryTypes.empty())
-            query.where("secondary_type = ?").bind(params.secondaryTypes);
-
-        switch (params.sortMethod)
+        template <typename ResultType>
+        Wt::Dbo::Query<ResultType> createQuery(Session& session, const Release::FindParameters& params)
         {
-        case ReleaseSortMethod::None:
-            break;
-        case ReleaseSortMethod::Name:
-            query.orderBy("r.name COLLATE NOCASE");
-            break;
-        case ReleaseSortMethod::Random:
-            query.orderBy("RANDOM()");
-            break;
-        case ReleaseSortMethod::LastWritten:
-            query.orderBy("t.file_last_write DESC");
-            break;
-        case ReleaseSortMethod::Date:
-            query.orderBy("t.date, r.name COLLATE NOCASE");
-            break;
-        case ReleaseSortMethod::OriginalDate:
-            query.orderBy("CASE WHEN t.original_date IS NULL THEN t.date ELSE t.original_date END, t.date, r.name COLLATE NOCASE");
-            break;
-        case ReleaseSortMethod::OriginalDateDesc:
-            query.orderBy("CASE WHEN t.original_date IS NULL THEN t.date ELSE t.original_date END DESC, t.date, r.name COLLATE NOCASE");
-            break;
-        case ReleaseSortMethod::StarredDateDesc:
-            assert(params.starringUser.isValid());
-            query.orderBy("s_r.date_time DESC");
-            break;
-        }
+            std::string_view itemToSelect;
+            
+            if constexpr (std::is_same_v<ResultType, ReleaseId>)
+                itemToSelect = "r.id";
+            else if constexpr (std::is_same_v<ResultType, Wt::Dbo::ptr<Release>>)
+                itemToSelect = "r";
+            else
+                static_assert("Unhandled type");
 
-        return query;
+            return createQuery<ResultType>(session, itemToSelect, params);
+        }
     }
 
     Release::Release(const std::string& name, const std::optional<UUID>& MBID)
@@ -233,7 +256,7 @@ namespace Database
         return session.getDboSession().query<int>("SELECT COUNT(*) FROM release");
     }
 
-    RangeResults<ReleaseId> Release::findOrderedByArtist(Session& session, Range range)
+    RangeResults<ReleaseId> Release::findIdsOrderedByArtist(Session& session, Range range)
     {
         session.checkSharedLocked();
 
@@ -248,7 +271,7 @@ namespace Database
         return Utils::execQuery(query, range);
     }
 
-    RangeResults<ReleaseId> Release::findOrphans(Session& session, Range range)
+    RangeResults<ReleaseId> Release::findOrphanIds(Session& session, Range range)
     {
         session.checkSharedLocked();
 
@@ -256,12 +279,19 @@ namespace Database
         return Utils::execQuery(query, range);
     }
 
-    RangeResults<ReleaseId> Release::find(Session& session, const FindParameters& params)
+    RangeResults<Release::pointer> Release::find(Session& session, const FindParameters& params)
     {
         session.checkSharedLocked();
 
-        auto query{ createQuery(session, params) };
+        auto query{ createQuery<Wt::Dbo::ptr<Release>>(session, params) };
+        return Utils::execQuery(query, params.range);
+    }
 
+    RangeResults<ReleaseId> Release::findIds(Session& session, const FindParameters& params)
+    {
+        session.checkSharedLocked();
+
+        auto query{ createQuery<ReleaseId>(session, params) };
         return Utils::execQuery(query, params.range);
     }
 
@@ -382,12 +412,18 @@ namespace Database
     {
         assert(session());
 
+        // Select the similar releases using the 5 most used clusters of the release
         auto res{ session()->query<Wt::Dbo::ptr<Release>>(
                 "SELECT r FROM release r"
                 " INNER JOIN track t ON t.release_id = r.id"
                 " INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
                     " WHERE "
-                        " t_c.cluster_id IN (SELECT c.id from cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN release r ON r.id = t.release_id WHERE r.id = ?)"
+                        " t_c.cluster_id IN "
+                        "(SELECT DISTINCT c.id FROM cluster c"
+                         " INNER JOIN track t ON c.id = t_c.cluster_id"
+                         " INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
+                         " INNER JOIN release r ON r.id = t.release_id"
+                         " WHERE r.id = ?)"
                         " AND r.id <> ?"
                     )
             .bind(getId())
diff --git a/src/libs/services/database/impl/Session.cpp b/src/libs/services/database/impl/Session.cpp
index 90387aaa..13589cc1 100644
--- a/src/libs/services/database/impl/Session.cpp
+++ b/src/libs/services/database/impl/Session.cpp
@@ -140,13 +140,13 @@ namespace Database
             _session.execute("CREATE INDEX IF NOT EXISTS release_name_idx ON release(name)");
             _session.execute("CREATE INDEX IF NOT EXISTS release_name_nocase_idx ON release(name COLLATE NOCASE)");
             _session.execute("CREATE INDEX IF NOT EXISTS release_mbid_idx ON release(mbid)");
-            _session.execute("CREATE INDEX IF NOT EXISTS track_file_last_write_idx ON track(file_last_write)");
             _session.execute("CREATE INDEX IF NOT EXISTS track_path_idx ON track(file_path)");
             _session.execute("CREATE INDEX IF NOT EXISTS track_name_idx ON track(name)");
             _session.execute("CREATE INDEX IF NOT EXISTS track_name_nocase_idx ON track(name COLLATE NOCASE)");
             _session.execute("CREATE INDEX IF NOT EXISTS track_mbid_idx ON track(mbid)");
             _session.execute("CREATE INDEX IF NOT EXISTS track_recording_mbid_idx ON track(recording_mbid)");
             _session.execute("CREATE INDEX IF NOT EXISTS track_release_idx ON track(release_id)");
+            _session.execute("CREATE INDEX IF NOT EXISTS track_file_last_write_idx ON track(file_last_write)");
             _session.execute("CREATE INDEX IF NOT EXISTS track_date_idx ON track(date)");
             _session.execute("CREATE INDEX IF NOT EXISTS track_original_date_idx ON track(original_date)");
             _session.execute("CREATE INDEX IF NOT EXISTS tracklist_name_idx ON tracklist(name)");
@@ -158,15 +158,16 @@ namespace Database
             _session.execute("CREATE INDEX IF NOT EXISTS track_artist_link_artist_type_idx ON track_artist_link(artist_id,type)");
             _session.execute("CREATE INDEX IF NOT EXISTS track_bookmark_user_idx ON track_bookmark(user_id)");
             _session.execute("CREATE INDEX IF NOT EXISTS track_bookmark_user_track_idx ON track_bookmark(user_id,track_id)");
-            _session.execute("CREATE INDEX IF NOT EXISTS listen_scrobbler_idx ON listen(scrobbler)");
-            _session.execute("CREATE INDEX IF NOT EXISTS listen_user_scrobbler_idx ON listen(user_id,scrobbler)");
-            _session.execute("CREATE INDEX IF NOT EXISTS listen_user_track_scrobbler_date_time_idx ON listen(user_id,track_id,scrobbler,date_time)");
-            _session.execute("CREATE INDEX IF NOT EXISTS starred_artist_user_scrobbler_idx ON starred_artist(user_id,scrobbler)");
-            _session.execute("CREATE INDEX IF NOT EXISTS starred_artist_artist_user_scrobbler_idx ON starred_artist(artist_id,user_id,scrobbler)");
-            _session.execute("CREATE INDEX IF NOT EXISTS starred_release_user_scrobbler_idx ON starred_release(user_id,scrobbler)");
-            _session.execute("CREATE INDEX IF NOT EXISTS starred_release_release_user_scrobbler_idx ON starred_release(release_id,user_id,scrobbler)");
-            _session.execute("CREATE INDEX IF NOT EXISTS starred_track_user_scrobbler_idx ON starred_track(user_id,scrobbler)");
-            _session.execute("CREATE INDEX IF NOT EXISTS starred_track_track_user_scrobbler_idx ON starred_track(track_id,user_id,scrobbler)");
+            _session.execute("CREATE INDEX IF NOT EXISTS listen_backend_idx ON listen(backend)");
+            _session.execute("CREATE INDEX IF NOT EXISTS listen_user_backend_idx ON listen(user_id,backend)");
+            _session.execute("CREATE INDEX IF NOT EXISTS listen_track_user_backend_idx ON listen(track_id,user_id,backend)");
+            _session.execute("CREATE INDEX IF NOT EXISTS listen_user_track_backend_date_time_idx ON listen(user_id,track_id,backend,date_time)");
+            _session.execute("CREATE INDEX IF NOT EXISTS starred_artist_user_backend_idx ON starred_artist(user_id,backend)");
+            _session.execute("CREATE INDEX IF NOT EXISTS starred_artist_artist_user_backend_idx ON starred_artist(artist_id,user_id,backend)");
+            _session.execute("CREATE INDEX IF NOT EXISTS starred_release_user_backend_idx ON starred_release(user_id,backend)");
+            _session.execute("CREATE INDEX IF NOT EXISTS starred_release_release_user_backend_idx ON starred_release(release_id,user_id,backend)");
+            _session.execute("CREATE INDEX IF NOT EXISTS starred_track_user_backend_idx ON starred_track(user_id,backend)");
+            _session.execute("CREATE INDEX IF NOT EXISTS starred_track_track_user_backend_idx ON starred_track(track_id,user_id,backend)");
         }
 
         // Initial settings tables
@@ -187,4 +188,14 @@ namespace Database
         LMS_LOG(DB, INFO) << "Database Analyze complete";
     }
 
+    void Session::optimize()
+    {
+        LMS_LOG(DB, INFO) << "Optimizing database...";
+        {
+            auto uniqueTransaction{ createUniqueTransaction() };
+            _session.execute("PRAGMA optimize");
+        }
+        LMS_LOG(DB, INFO) << "Database optimizing complete";
+    }
+
 } // namespace Database
diff --git a/src/libs/services/database/impl/StarredArtist.cpp b/src/libs/services/database/impl/StarredArtist.cpp
index ca4b3638..0427c80b 100644
--- a/src/libs/services/database/impl/StarredArtist.cpp
+++ b/src/libs/services/database/impl/StarredArtist.cpp
@@ -29,47 +29,42 @@
 
 namespace Database
 {
-	StarredArtist::StarredArtist(ObjectPtr<Artist> artist, ObjectPtr<User> user, Scrobbler scrobbler)
-		: _scrobbler {scrobbler}
-		, _artist {getDboPtr(artist)}
-		, _user {getDboPtr(user)}
-	{
-	}
+    StarredArtist::StarredArtist(ObjectPtr<Artist> artist, ObjectPtr<User> user, FeedbackBackend backend)
+        : _backend{ backend }
+        , _artist{ getDboPtr(artist) }
+        , _user{ getDboPtr(user) }
+    {
+    }
 
-	StarredArtist::pointer
-	StarredArtist::create(Session& session, ObjectPtr<Artist> artist, ObjectPtr<User> user, Scrobbler scrobbler)
-	{
-		return session.getDboSession().add(std::unique_ptr<StarredArtist> {new StarredArtist {artist, user, scrobbler}});
-	}
+    StarredArtist::pointer StarredArtist::create(Session& session, ObjectPtr<Artist> artist, ObjectPtr<User> user, FeedbackBackend backend)
+    {
+        return session.getDboSession().add(std::unique_ptr<StarredArtist> {new StarredArtist{ artist, user, backend }});
+    }
 
-	std::size_t
-	StarredArtist::getCount(Session& session)
-	{
-		session.checkSharedLocked();
-		return session.getDboSession().query<int>("SELECT COUNT(*) FROM starred_artist");
-	}
+    std::size_t StarredArtist::getCount(Session& session)
+    {
+        session.checkSharedLocked();
+        return session.getDboSession().query<int>("SELECT COUNT(*) FROM starred_artist");
+    }
 
-	StarredArtist::pointer
-	StarredArtist::find(Session& session, StarredArtistId id)
-	{
-		session.checkSharedLocked();
-		return session.getDboSession().find<StarredArtist>().where("id = ?").bind(id).resultValue();
-	}
+    StarredArtist::pointer StarredArtist::find(Session& session, StarredArtistId id)
+    {
+        session.checkSharedLocked();
+        return session.getDboSession().find<StarredArtist>().where("id = ?").bind(id).resultValue();
+    }
 
-	StarredArtist::pointer
-	StarredArtist::find(Session& session, ArtistId artistId, UserId userId, Scrobbler scrobbler)
-	{
-		session.checkSharedLocked();
-		return session.getDboSession().find<StarredArtist>()
-			.where("artist_id = ?").bind(artistId)
-			.where("user_id = ?").bind(userId)
-			.where("scrobbler = ?").bind(scrobbler)
-			.resultValue();
-	}
+    StarredArtist::pointer StarredArtist::find(Session& session, ArtistId artistId, UserId userId, FeedbackBackend backend)
+    {
+        session.checkSharedLocked();
+        return session.getDboSession().find<StarredArtist>()
+            .where("artist_id = ?").bind(artistId)
+            .where("user_id = ?").bind(userId)
+            .where("backend = ?").bind(backend)
+            .resultValue();
+    }
 
-	void
-	StarredArtist::setDateTime(const Wt::WDateTime& dateTime)
-	{
-		_dateTime = Utils::normalizeDateTime(dateTime);
-	}
+    void StarredArtist::setDateTime(const Wt::WDateTime& dateTime)
+    {
+        _dateTime = Utils::normalizeDateTime(dateTime);
+    }
 }
diff --git a/src/libs/services/database/impl/StarredRelease.cpp b/src/libs/services/database/impl/StarredRelease.cpp
index 17f1c598..7645d3f9 100644
--- a/src/libs/services/database/impl/StarredRelease.cpp
+++ b/src/libs/services/database/impl/StarredRelease.cpp
@@ -29,47 +29,42 @@
 
 namespace Database
 {
-	StarredRelease::StarredRelease(ObjectPtr<Release> release, ObjectPtr<User> user, Scrobbler scrobbler)
-		: _scrobbler {scrobbler}
-		, _release {getDboPtr(release)}
-		, _user {getDboPtr(user)}
-	{
-	}
+    StarredRelease::StarredRelease(ObjectPtr<Release> release, ObjectPtr<User> user, FeedbackBackend backend)
+        : _backend{ backend }
+        , _release{ getDboPtr(release) }
+        , _user{ getDboPtr(user) }
+    {
+    }
 
-	StarredRelease::pointer
-	StarredRelease::create(Session& session, ObjectPtr<Release> release, ObjectPtr<User> user, Scrobbler scrobbler)
-	{
-		return session.getDboSession().add(std::unique_ptr<StarredRelease>{new StarredRelease{release, user, scrobbler}});
-	}
+    StarredRelease::pointer StarredRelease::create(Session& session, ObjectPtr<Release> release, ObjectPtr<User> user, FeedbackBackend backend)
+    {
+        return session.getDboSession().add(std::unique_ptr<StarredRelease>{new StarredRelease{ release, user, backend }});
+    }
 
-	std::size_t
-	StarredRelease::getCount(Session& session)
-	{
-		session.checkSharedLocked();
-		return session.getDboSession().query<int>("SELECT COUNT(*) FROM starred_release");
-	}
+    std::size_t StarredRelease::getCount(Session& session)
+    {
+        session.checkSharedLocked();
+        return session.getDboSession().query<int>("SELECT COUNT(*) FROM starred_release");
+    }
 
-	StarredRelease::pointer
-	StarredRelease::find(Session& session, StarredReleaseId id)
-	{
-		session.checkSharedLocked();
-		return session.getDboSession().find<StarredRelease>().where("id = ?").bind(id).resultValue();
-	}
+    StarredRelease::pointer StarredRelease::find(Session& session, StarredReleaseId id)
+    {
+        session.checkSharedLocked();
+        return session.getDboSession().find<StarredRelease>().where("id = ?").bind(id).resultValue();
+    }
 
-	StarredRelease::pointer
-	StarredRelease::find(Session& session, ReleaseId releaseId, UserId userId, Scrobbler scrobbler)
-	{
-		session.checkSharedLocked();
-		return session.getDboSession().find<StarredRelease>()
-			.where("release_id = ?").bind(releaseId)
-			.where("user_id = ?").bind(userId)
-			.where("scrobbler = ?").bind(scrobbler)
-			.resultValue();
-	}
+    StarredRelease::pointer StarredRelease::find(Session& session, ReleaseId releaseId, UserId userId, FeedbackBackend backend)
+    {
+        session.checkSharedLocked();
+        return session.getDboSession().find<StarredRelease>()
+            .where("release_id = ?").bind(releaseId)
+            .where("user_id = ?").bind(userId)
+            .where("backend = ?").bind(backend)
+            .resultValue();
+    }
 
-	void
-	StarredRelease::setDateTime(const Wt::WDateTime& dateTime)
-	{
-		_dateTime = Utils::normalizeDateTime(dateTime);
-	}
+    void StarredRelease::setDateTime(const Wt::WDateTime& dateTime)
+    {
+        _dateTime = Utils::normalizeDateTime(dateTime);
+    }
 }
diff --git a/src/libs/services/database/impl/StarredTrack.cpp b/src/libs/services/database/impl/StarredTrack.cpp
index 21158c9a..2f03fbe6 100644
--- a/src/libs/services/database/impl/StarredTrack.cpp
+++ b/src/libs/services/database/impl/StarredTrack.cpp
@@ -29,64 +29,58 @@
 
 namespace Database
 {
-	StarredTrack::StarredTrack(ObjectPtr<Track> track, ObjectPtr<User> user, Scrobbler scrobbler)
-		: _scrobbler {scrobbler}
-		, _track {getDboPtr(track)}
-		, _user {getDboPtr(user)}
-	{
-	}
+    StarredTrack::StarredTrack(ObjectPtr<Track> track, ObjectPtr<User> user, FeedbackBackend backend)
+        : _backend{ backend }
+        , _track{ getDboPtr(track) }
+        , _user{ getDboPtr(user) }
+    {
+    }
 
-	StarredTrack::pointer
-	StarredTrack::create(Session& session, ObjectPtr<Track> track, ObjectPtr<User> user, Scrobbler scrobbler)
-	{
-		return session.getDboSession().add(std::unique_ptr<StarredTrack> {new StarredTrack{track, user, scrobbler}});
-	}
+    StarredTrack::pointer StarredTrack::create(Session& session, ObjectPtr<Track> track, ObjectPtr<User> user, FeedbackBackend backend)
+    {
+        return session.getDboSession().add(std::unique_ptr<StarredTrack> {new StarredTrack{ track, user, backend }});
+    }
 
-	std::size_t
-	StarredTrack::getCount(Session& session)
-	{
-		session.checkSharedLocked();
-		return session.getDboSession().query<int>("SELECT COUNT(*) FROM starred_track");
-	}
+    std::size_t StarredTrack::getCount(Session& session)
+    {
+        session.checkSharedLocked();
+        return session.getDboSession().query<int>("SELECT COUNT(*) FROM starred_track");
+    }
 
-	StarredTrack::pointer
-	StarredTrack::find(Session& session, StarredTrackId id)
-	{
-		session.checkSharedLocked();
-		return session.getDboSession().find<StarredTrack>().where("id = ?").bind(id).resultValue();
-	}
+    StarredTrack::pointer StarredTrack::find(Session& session, StarredTrackId id)
+    {
+        session.checkSharedLocked();
+        return session.getDboSession().find<StarredTrack>().where("id = ?").bind(id).resultValue();
+    }
 
-	StarredTrack::pointer
-	StarredTrack::find(Session& session, TrackId trackId, UserId userId, Scrobbler scrobbler)
-	{
-		session.checkSharedLocked();
-		return session.getDboSession().find<StarredTrack>()
-			.where("track_id = ?").bind(trackId)
-			.where("user_id = ?").bind(userId)
-			.where("scrobbler = ?").bind(scrobbler)
-			.resultValue();
-	}
+    StarredTrack::pointer StarredTrack::find(Session& session, TrackId trackId, UserId userId, FeedbackBackend backend)
+    {
+        session.checkSharedLocked();
+        return session.getDboSession().find<StarredTrack>()
+            .where("track_id = ?").bind(trackId)
+            .where("user_id = ?").bind(userId)
+            .where("backend = ?").bind(backend)
+            .resultValue();
+    }
 
-	RangeResults<StarredTrackId>
-	StarredTrack::find(Session& session, const FindParameters& params)
-	{
-		session.checkSharedLocked();
+    RangeResults<StarredTrackId> StarredTrack::find(Session& session, const FindParameters& params)
+    {
+        session.checkSharedLocked();
 
-		auto query {session.getDboSession().query<StarredTrackId>("SELECT DISTINCT s_t.id FROM starred_track s_t")};
+        auto query{ session.getDboSession().query<StarredTrackId>("SELECT DISTINCT s_t.id FROM starred_track s_t") };
 
-		if (params.scrobbler)
-			query.where("s_t.scrobbler = ?").bind(*params.scrobbler);
-		if (params.scrobblingState)
-			query.where("s_t.scrobbling_state = ?").bind(*params.scrobblingState);
-		if (params.user.isValid())
-			query.where("s_t.user_id = ?").bind(params.user);
+        if (params.backend)
+            query.where("s_t.backend = ?").bind(*params.backend);
+        if (params.syncState)
+            query.where("s_t.sync_state = ?").bind(*params.syncState);
+        if (params.user.isValid())
+            query.where("s_t.user_id = ?").bind(params.user);
 
-		return Utils::execQuery(query, params.range);
-	}
+        return Utils::execQuery(query, params.range);
+    }
 
-	void
-	StarredTrack::setDateTime(const Wt::WDateTime& dateTime)
-	{
-		_dateTime = Utils::normalizeDateTime(dateTime);
-	}
+    void StarredTrack::setDateTime(const Wt::WDateTime& dateTime)
+    {
+        _dateTime = Utils::normalizeDateTime(dateTime);
+    }
 }
diff --git a/src/libs/services/database/impl/Track.cpp b/src/libs/services/database/impl/Track.cpp
index 993acdc1..be1f0a16 100644
--- a/src/libs/services/database/impl/Track.cpp
+++ b/src/libs/services/database/impl/Track.cpp
@@ -35,504 +35,507 @@
 #include "StringViewTraits.hpp"
 #include "Utils.hpp"
 
-namespace Database {
-
-static
-Wt::Dbo::Query<TrackId>
-createQuery(Session& session, const Track::FindParameters& params)
+namespace Database
 {
-	session.checkSharedLocked();
-
-	auto query {session.getDboSession().query<TrackId>(params.distinct ? "SELECT DISTINCT t.id FROM track t" : "SELECT t.id FROM track t")};
-
-	assert(params.keywords.empty() || params.name.empty());
-	for (std::string_view keyword : params.keywords)
-		query.where("t.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'").bind("%" + Utils::escapeLikeKeyword(keyword) + "%");
-
-	if (!params.name.empty())
-		query.where("t.name = ?").bind(params.name);
-
-	if (params.writtenAfter.isValid())
-		query.where("t.file_last_write > ?").bind(params.writtenAfter);
-
-	if (params.starringUser.isValid())
-	{
-		assert(params.scrobbler);
-		query.join("starred_track s_t ON s_t.track_id = t.id")
-			.where("s_t.user_id = ?").bind(params.starringUser)
-			.where("s_t.scrobbler = ?").bind(*params.scrobbler)
-			.where("s_t.scrobbling_state <> ?").bind(ScrobblingState::PendingRemove);
-	}
-
-	if (!params.clusters.empty())
-	{
-		std::ostringstream oss;
-		oss << "t.id IN (SELECT DISTINCT t.id FROM track t"
-			" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
-			" INNER JOIN cluster c ON c.id = t_c.cluster_id";
-
-		WhereClause clusterClause;
-		for (const ClusterId clusterId : params.clusters)
-		{
-			clusterClause.Or(WhereClause("c.id = ?"));
-			query.bind(clusterId);
-		}
-
-		oss << " " << clusterClause.get();
-		oss << " GROUP BY t.id HAVING COUNT(*) = " << params.clusters.size() << ")";
-
-		query.where(oss.str());
-	}
-
-	if (params.artist.isValid() || !params.artistName.empty())
-	{
-		query.join("artist a ON a.id = t_a_l.artist_id")
-				.join("track_artist_link t_a_l ON t_a_l.track_id = t.id");
-
-		if (params.artist.isValid())
-			query.where("a.id = ?").bind(params.artist);
-		if (!params.artistName.empty())
-			query.where("a.name = ?").bind(params.artistName);
-
-		if (!params.trackArtistLinkTypes.empty())
-		{
-			std::ostringstream oss;
-
-			bool first {true};
-			for (TrackArtistLinkType linkType : params.trackArtistLinkTypes)
-			{
-				if (!first)
-					oss << " OR ";
-				oss << "t_a_l.type = ?";
-				query.bind(linkType);
-
-				first = false;
-			}
-			query.where(oss.str());
-		}
-	}
-
-	assert(!(params.nonRelease && params.release.isValid()));
-	if (params.nonRelease)
-		query.where("t.release_id IS NULL");
-	else if (params.release.isValid())
-		query.where("t.release_id = ?").bind(params.release);
-	else if (!params.releaseName.empty())
-	{
-		query.join("release r ON t.release_id = r.id");
-		query.where("r.name = ?").bind(params.releaseName);
-	}
-
-	if (params.trackList.isValid())
-	{
-		query.join("tracklist t_l ON t_l_e.tracklist_id = t_l.id");
-		query.join("tracklist_entry t_l_e ON t.id = t_l_e.track_id");
-		query.where("t_l.id = ?").bind(params.trackList);
-	}
-
-	if (params.trackNumber)
-		query.where("t.track_number = ?").bind(*params.trackNumber);
-
-	switch (params.sortMethod)
-	{
-		case TrackSortMethod::None:
-			break;
-		case TrackSortMethod::LastWritten:
-			query.orderBy("t.file_last_write DESC");
-			break;
-		case TrackSortMethod::Random:
-			query.orderBy("RANDOM()");
-			break;
-		case TrackSortMethod::StarredDateDesc:
-			assert(params.starringUser.isValid());
-			query.orderBy("s_t.date_time DESC");
-			break;
-		case TrackSortMethod::Name:
-			query.orderBy("t.name COLLATE NOCASE");
-			break;
-		case TrackSortMethod::DateDescAndRelease:
-			query.orderBy("t.date DESC,t.release_id,t.disc_number,t.track_number");
-			break;
-		case TrackSortMethod::Release:
-			query.orderBy("t.disc_number,t.track_number");
-			break;
-		case TrackSortMethod::TrackList:
-			assert(params.trackList.isValid());
-			query.orderBy("t_l.id");
-	}
-
-	return query;
-}
-
-Track::Track(const std::filesystem::path& p)
-: _filePath {p.string()}
-{
-}
-
-Track::pointer
-Track::create(Session& session, const std::filesystem::path& p)
-{
-	return session.getDboSession().add(std::unique_ptr<Track> {new Track {p}});
-}
-
-std::size_t
-Track::getCount(Session& session)
-{
-	session.checkSharedLocked();
-
-	return session.getDboSession().query<int>("SELECT COUNT(*) FROM track");
-}
-
-Track::pointer
-Track::findByPath(Session& session, const std::filesystem::path& p)
-{
-	session.checkSharedLocked();
-
-	return session.getDboSession().find<Track>().where("file_path = ?").bind(p.string()).resultValue();
-}
-
-Track::pointer
-Track::find(Session& session, TrackId id)
-{
-	session.checkSharedLocked();
-
-	return session.getDboSession().find<Track>()
-		.where("id = ?").bind(id)
-		.resultValue();
-}
-
-bool
-Track::exists(Session& session, TrackId id)
-{
-	session.checkSharedLocked();
-
-	return session.getDboSession().query<int>("SELECT 1 from track").where("id = ?").bind(id).resultValue() == 1;
-}
-
-std::vector<Track::pointer>
-Track::findByMBID(Session& session, const UUID& mbid)
-{
-	session.checkSharedLocked();
-
-	auto res {session.getDboSession().find<Track>()
-		.where("mbid = ?").bind(std::string {mbid.getAsString()})
-		.resultList()};
-
-	return std::vector<Track::pointer>(res.begin(), res.end());
-}
-
-std::vector<Track::pointer>
-Track::findByRecordingMBID(Session& session, const UUID& mbid)
-{
-	session.checkSharedLocked();
-
-	auto res {session.getDboSession().find<Track>()
-		.where("recording_mbid = ?").bind(std::string {mbid.getAsString()})
-		.resultList()};
-
-	return std::vector<Track::pointer>(res.begin(), res.end());
-}
-
-RangeResults<Track::PathResult>
-Track::findPaths(Session& session, Range range)
-{
-	using QueryResultType = std::tuple<TrackId, std::string>;
-	session.checkSharedLocked();
-
-	// TODO Dbo traits on filesystem
-	auto query {session.getDboSession().query<QueryResultType>("SELECT id, file_path FROM track")};
-
-	RangeResults<QueryResultType> queryResults {Utils::execQuery(query, range)};
-
-	RangeResults<PathResult> res;
-	res.range = queryResults.range;
-	res.moreResults = queryResults.moreResults;
-	res.results.reserve(queryResults.results.size());
-
-	std::transform(std::cbegin(queryResults.results), std::cend(queryResults.results), std::back_inserter(res.results),
-			[](const QueryResultType& queryResult)
-			{
-				return PathResult {std::get<0>(queryResult), std::get<1>(queryResult)};
-			});
-
-	return res;
-}
-
-RangeResults<TrackId>
-Track::findTrackMBIDDuplicates(Session& session, Range range)
-{
-	session.checkSharedLocked();
-
-	auto query {session.getDboSession().query<TrackId>( "SELECT track.id FROM track WHERE mbid in (SELECT mbid FROM track WHERE mbid <> '' GROUP BY mbid HAVING COUNT (*) > 1)")
-		.orderBy("track.release_id,track.disc_number,track.track_number,track.mbid")};
-
-	return Utils::execQuery(query, range);
-}
-
-RangeResults<TrackId>
-Track::findWithRecordingMBIDAndMissingFeatures(Session& session, Range range)
-{
-	session.checkSharedLocked();
-
-	auto query {session.getDboSession().query<TrackId>("SELECT t.id FROM track t")
-		.where("LENGTH(t.recording_mbid) > 0")
-		.where("NOT EXISTS (SELECT * FROM track_features t_f WHERE t_f.track_id = t.id)")};
-
-	return Utils::execQuery(query, range);
-}
-
-std::vector<Cluster::pointer>
-Track::getClusters() const
-{
-	return std::vector<Cluster::pointer>(_clusters.begin(), _clusters.end());
-}
-
-std::vector<ClusterId>
-Track::getClusterIds() const
-{
-	assert(session());
-
-	auto res {session()->query<ClusterId>
-		("SELECT DISTINCT c.id FROM cluster c INNER JOIN track_cluster t_c ON t_c.cluster_id = c.id INNER JOIN track t ON t.id = t_c.track_id")
-		.where("t.id = ?").bind(getId())
-		.resultList()};
-
-	return std::vector<ClusterId>(res.begin(), res.end());
-}
-
-RangeResults<TrackId>
-Track::find(Session& session, const FindParameters& parameters)
-{
-	session.checkSharedLocked();
-
-	auto query {createQuery(session, parameters)};
-
-	return Utils::execQuery(query, parameters.range);
-}
-
-RangeResults<TrackId>
-Track::findSimilarTracks(Session& session, const std::vector<TrackId>& tracks, Range range)
-{
-	assert(!tracks.empty());
-	session.checkSharedLocked();
-
-	std::ostringstream oss;
-	for (std::size_t i {}; i < tracks.size(); ++i)
-	{
-		if (!oss.str().empty())
-			oss << ", ";
-		oss << "?";
-	}
-
-	auto query {session.getDboSession().query<TrackId>(
-			"SELECT t.id FROM track t"
-			" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
-					" AND t_c.cluster_id IN (SELECT c.id FROM cluster c INNER JOIN track_cluster t_c ON t_c.cluster_id = c.id WHERE t_c.track_id IN (" + oss.str() + "))"
-					" AND t.id NOT IN (" + oss.str() + ")")
-		.groupBy("t.id")
-		.orderBy("COUNT(*) DESC, RANDOM()")};
-
-	for (TrackId trackId : tracks)
-		query.bind(trackId);
-
-	for (TrackId trackId : tracks)
-		query.bind(trackId);
-
-	return Utils::execQuery(query, range);
-}
-
-void
-Track::clearArtistLinks()
-{
-	_trackArtistLinks.clear();
-}
-
-void
-Track::addArtistLink(const ObjectPtr<TrackArtistLink>& artistLink)
-{
-	_trackArtistLinks.insert(getDboPtr(artistLink));
-}
-
-void
-Track::setClusters(const std::vector<ObjectPtr<Cluster>>& clusters)
-{
-	_clusters.clear();
-	for (const ObjectPtr<Cluster>& cluster : clusters)
-		_clusters.insert(getDboPtr(cluster));
-}
-
-std::optional<int>
-Track::getYear() const
-{
-	return (_date.isValid() ? std::make_optional<int>(_date.year()) : std::nullopt);
-}
-
-std::optional<int>
-Track::getOriginalYear() const
-{
-	return (_originalDate.isValid() ? std::make_optional<int>(_originalDate.year()) : std::nullopt);
-}
-
-std::optional<std::string>
-Track::getCopyright() const
-{
-	return _copyright != "" ? std::make_optional<std::string>(_copyright) : std::nullopt;
-}
-
-std::optional<std::string>
-Track::getCopyrightURL() const
-{
-	return _copyrightURL != "" ? std::make_optional<std::string>(_copyrightURL) : std::nullopt;
-}
-
-std::vector<Artist::pointer>
-Track::getArtists(EnumSet<TrackArtistLinkType> linkTypes) const
-{
-	assert(session());
-
-	std::ostringstream oss;
-	oss <<
-		"SELECT a from artist a"
-		" INNER JOIN track_artist_link t_a_l ON a.id = t_a_l.artist_id"
-		" INNER JOIN track t ON t.id = t_a_l.track_id";
-
-	if (!linkTypes.empty())
-	{
-		oss << " AND t_a_l.type IN (";
-
-		bool first {true};
-		for ([[maybe_unused]] TrackArtistLinkType type : linkTypes)
-		{
-			if (!first)
-				oss << ", ";
-			oss << "?";
-			first = false;
-		}
-		oss << ")";
-	}
-
-	auto query {session()->query<Wt::Dbo::ptr<Artist>>(oss.str())};
-	for (TrackArtistLinkType type : linkTypes)
-		query.bind(type);
-
-	query.where("t.id = ?").bind(getId());
-
-	auto res {query.resultList()};
-	return std::vector<Artist::pointer>(std::begin(res), std::end(res));
-}
-
-std::vector<ArtistId>
-Track::getArtistIds(EnumSet<TrackArtistLinkType> linkTypes) const
-{
-	assert(self());
-	assert(session());
-
-	std::ostringstream oss;
-	oss <<
-		"SELECT DISTINCT a.id from artist a"
-		" INNER JOIN track_artist_link t_a_l ON a.id = t_a_l.artist_id"
-		" INNER JOIN track t ON t.id = t_a_l.track_id";
-
-	if (!linkTypes.empty())
-	{
-		oss << " AND t_a_l.type IN (";
-
-		bool first {true};
-		for ([[maybe_unused]] TrackArtistLinkType type : linkTypes)
-		{
-			if (!first)
-				oss << ", ";
-			oss << "?";
-			first = false;
-		}
-		oss << ")";
-	}
-
-	auto query {session()->query<ArtistId>(oss.str())};
-	for (TrackArtistLinkType type : linkTypes)
-		query.bind(type);
-
-	query.where("t.id = ?").bind(getId());
-
-	auto res {query.resultList()};
-	return std::vector<ArtistId>(std::cbegin(res), std::cend(res));
-}
-
-std::vector<TrackArtistLink::pointer>
-Track::getArtistLinks() const
-{
-	return std::vector<TrackArtistLink::pointer>(_trackArtistLinks.begin(), _trackArtistLinks.end());
-}
-
-std::vector<std::vector<Cluster::pointer>>
-Track::getClusterGroups(const std::vector<ClusterType::pointer>& clusterTypes, std::size_t size) const
-{
-	assert(self());
-	assert(session());
-
-	WhereClause where;
-
-	std::ostringstream oss;
-
-	oss << "SELECT c from cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN cluster_type c_type ON c.cluster_type_id = c_type.id";
-
-	where.And(WhereClause("t.id = ?")).bind(getId().toString());
-	{
-		WhereClause clusterClause;
-		for (auto clusterType : clusterTypes)
-			clusterClause.Or(WhereClause("c_type.id = ?")).bind(clusterType->getId().toString());
-		where.And(clusterClause);
-	}
-	oss << " " << where.get();
-	oss << " GROUP BY c.id ORDER BY COUNT(c.id) DESC";
-
-	auto query {session()->query<Wt::Dbo::ptr<Cluster>>(oss.str())};
-	for (const std::string& bindArg : where.getBindArgs())
-		query.bind(bindArg);
-
-	auto queryRes {query.resultList()};
-
-	std::map<ClusterTypeId, std::vector<Cluster::pointer>> clusters;
-	for (const Wt::Dbo::ptr<Cluster>& cluster : queryRes)
-	{
-		if (clusters[cluster->getType()->getId()].size() < size)
-			clusters[cluster->getType()->getId()].push_back(cluster);
-	}
-
-	std::vector<std::vector<Cluster::pointer>> res;
-	for (auto cluster_list : clusters)
-		res.push_back(cluster_list.second);
-
-	return res;
-}
-
-namespace Debug
-{
-	std::ostream&
-	operator<<(std::ostream& os, const TrackInfo& trackInfo)
-	{
-		auto transaction {trackInfo.session.createSharedTransaction()};
-
-		const Track::pointer track {Track::find(trackInfo.session, trackInfo.trackId)};
-		if (track)
-		{
-			os << track->getName();
-
-			if (const Release::pointer release {track->getRelease()})
-				os << " [" << release->getName() << "]";
-			for (auto artist : track->getArtists({TrackArtistLinkType::Artist}))
-				os << " - " << artist->getName();
-			for (auto cluster : track->getClusters())
-				os << " {" + cluster->getType()->getName() << "-" << cluster->getName() << "}";
-		}
-		else
-		{
-			os << "*unknown*";
-		}
-
-		return os;
-	}
-}
+    namespace
+    {
+        template <typename ResultType>
+        Wt::Dbo::Query<ResultType> createQuery(Session& session, std::string_view itemToSelect, const Track::FindParameters& params)
+        {
+            session.checkSharedLocked();
+
+            auto query{ session.getDboSession().query<ResultType>(params.distinct ? "SELECT DISTINCT " + std::string{ itemToSelect } + " FROM track t" : "SELECT t.id FROM track t") };
+
+            assert(params.keywords.empty() || params.name.empty());
+            for (std::string_view keyword : params.keywords)
+                query.where("t.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'").bind("%" + Utils::escapeLikeKeyword(keyword) + "%");
+
+            if (!params.name.empty())
+                query.where("t.name = ?").bind(params.name);
+
+            if (params.writtenAfter.isValid())
+                query.where("t.file_last_write > ?").bind(params.writtenAfter);
+
+            if (params.starringUser.isValid())
+            {
+                assert(params.feedbackBackend);
+                query.join("starred_track s_t ON s_t.track_id = t.id")
+                    .where("s_t.user_id = ?").bind(params.starringUser)
+                    .where("s_t.backend = ?").bind(*params.feedbackBackend)
+                    .where("s_t.sync_state <> ?").bind(SyncState::PendingRemove);
+            }
+
+            if (params.clusters.size() == 1)
+            {
+                // optim
+                query.join("track_cluster t_c ON t_c.track_id = t.id")
+                    .where("t_c.cluster_id = ?").bind(params.clusters.front());
+            }
+            else if (params.clusters.size() > 1)
+            {
+                std::ostringstream oss;
+                oss << "t.id IN (SELECT DISTINCT t.id FROM track t"
+                    " INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
+
+                WhereClause clusterClause;
+                for (const ClusterId clusterId : params.clusters)
+                {
+                    clusterClause.Or(WhereClause("t_c.cluster_id = ?"));
+                    query.bind(clusterId);
+                }
+
+                oss << " " << clusterClause.get();
+                oss << " GROUP BY t.id HAVING COUNT(*) = " << params.clusters.size() << ")";
+
+                query.where(oss.str());
+            }
+
+            if (params.artist.isValid() || !params.artistName.empty())
+            {
+                query.join("artist a ON a.id = t_a_l.artist_id")
+                    .join("track_artist_link t_a_l ON t_a_l.track_id = t.id");
+
+                if (params.artist.isValid())
+                    query.where("a.id = ?").bind(params.artist);
+                if (!params.artistName.empty())
+                    query.where("a.name = ?").bind(params.artistName);
+
+                if (!params.trackArtistLinkTypes.empty())
+                {
+                    std::ostringstream oss;
+
+                    bool first{ true };
+                    for (TrackArtistLinkType linkType : params.trackArtistLinkTypes)
+                    {
+                        if (!first)
+                            oss << " OR ";
+                        oss << "t_a_l.type = ?";
+                        query.bind(linkType);
+
+                        first = false;
+                    }
+                    query.where(oss.str());
+                }
+            }
+
+            assert(!(params.nonRelease && params.release.isValid()));
+            if (params.nonRelease)
+                query.where("t.release_id IS NULL");
+            else if (params.release.isValid())
+                query.where("t.release_id = ?").bind(params.release);
+            else if (!params.releaseName.empty())
+            {
+                query.join("release r ON t.release_id = r.id");
+                query.where("r.name = ?").bind(params.releaseName);
+            }
+
+            if (params.trackList.isValid())
+            {
+                query.join("tracklist t_l ON t_l_e.tracklist_id = t_l.id");
+                query.join("tracklist_entry t_l_e ON t.id = t_l_e.track_id");
+                query.where("t_l.id = ?").bind(params.trackList);
+            }
+
+            if (params.trackNumber)
+                query.where("t.track_number = ?").bind(*params.trackNumber);
+
+            switch (params.sortMethod)
+            {
+            case TrackSortMethod::None:
+                break;
+            case TrackSortMethod::LastWritten:
+                query.orderBy("t.file_last_write DESC");
+                break;
+            case TrackSortMethod::Random:
+                query.orderBy("RANDOM()");
+                break;
+            case TrackSortMethod::StarredDateDesc:
+                assert(params.starringUser.isValid());
+                query.orderBy("s_t.date_time DESC");
+                break;
+            case TrackSortMethod::Name:
+                query.orderBy("t.name COLLATE NOCASE");
+                break;
+            case TrackSortMethod::DateDescAndRelease:
+                query.orderBy("t.date DESC,t.release_id,t.disc_number,t.track_number");
+                break;
+            case TrackSortMethod::Release:
+                query.orderBy("t.disc_number,t.track_number");
+                break;
+            case TrackSortMethod::TrackList:
+                assert(params.trackList.isValid());
+                query.orderBy("t_l.id");
+            }
+
+            return query;
+        }
+        
+        template <typename ResultType>
+        Wt::Dbo::Query<ResultType> createQuery(Session& session, const Track::FindParameters& params)
+        {
+            std::string_view itemToSelect;
+            
+            if constexpr (std::is_same_v<ResultType, TrackId>)
+                itemToSelect = "t.id";
+            else if constexpr (std::is_same_v<ResultType, Wt::Dbo::ptr<Track>>)
+                itemToSelect = "t";
+            else
+                static_assert("Unhandled type");
+
+            return createQuery<ResultType>(session, itemToSelect, params);
+        }
+    }
+
+    Track::Track(const std::filesystem::path& p)
+        : _filePath{ p.string() }
+    {
+    }
+
+    Track::pointer Track::create(Session& session, const std::filesystem::path& p)
+    {
+        return session.getDboSession().add(std::unique_ptr<Track> {new Track{ p }});
+    }
+
+    std::size_t
+        Track::getCount(Session& session)
+    {
+        session.checkSharedLocked();
+
+        return session.getDboSession().query<int>("SELECT COUNT(*) FROM track");
+    }
+
+    Track::pointer Track::findByPath(Session& session, const std::filesystem::path& p)
+    {
+        session.checkSharedLocked();
+
+        return session.getDboSession().find<Track>().where("file_path = ?").bind(p.string()).resultValue();
+    }
+
+    Track::pointer Track::find(Session& session, TrackId id)
+    {
+        session.checkSharedLocked();
+
+        return session.getDboSession().find<Track>()
+            .where("id = ?").bind(id)
+            .resultValue();
+    }
+
+    bool Track::exists(Session& session, TrackId id)
+    {
+        session.checkSharedLocked();
+
+        return session.getDboSession().query<int>("SELECT 1 from track").where("id = ?").bind(id).resultValue() == 1;
+    }
+
+    std::vector<Track::pointer> Track::findByMBID(Session& session, const UUID& mbid)
+    {
+        session.checkSharedLocked();
+
+        auto res{ session.getDboSession().find<Track>()
+            .where("mbid = ?").bind(std::string {mbid.getAsString()})
+            .resultList() };
+
+        return std::vector<Track::pointer>(res.begin(), res.end());
+    }
+
+    std::vector<Track::pointer> Track::findByRecordingMBID(Session& session, const UUID& mbid)
+    {
+        session.checkSharedLocked();
+
+        auto res{ session.getDboSession().find<Track>()
+            .where("recording_mbid = ?").bind(std::string {mbid.getAsString()})
+            .resultList() };
+
+        return std::vector<Track::pointer>(res.begin(), res.end());
+    }
+
+    RangeResults<Track::PathResult> Track::findPaths(Session& session, Range range)
+    {
+        using QueryResultType = std::tuple<TrackId, std::string>;
+        session.checkSharedLocked();
+
+        // TODO Dbo traits on filesystem
+        auto query{ session.getDboSession().query<QueryResultType>("SELECT id, file_path FROM track") };
+
+        RangeResults<QueryResultType> queryResults{ Utils::execQuery(query, range) };
+
+        RangeResults<PathResult> res;
+        res.range = queryResults.range;
+        res.moreResults = queryResults.moreResults;
+        res.results.reserve(queryResults.results.size());
+
+        std::transform(std::cbegin(queryResults.results), std::cend(queryResults.results), std::back_inserter(res.results),
+            [](const QueryResultType& queryResult)
+            {
+                return PathResult{ std::get<0>(queryResult), std::get<1>(queryResult) };
+            });
+
+        return res;
+    }
+
+    RangeResults<TrackId> Track::findIdsTrackMBIDDuplicates(Session& session, Range range)
+    {
+        session.checkSharedLocked();
+
+        auto query{ session.getDboSession().query<TrackId>("SELECT track.id FROM track WHERE mbid in (SELECT mbid FROM track WHERE mbid <> '' GROUP BY mbid HAVING COUNT (*) > 1)")
+            .orderBy("track.release_id,track.disc_number,track.track_number,track.mbid") };
+
+        return Utils::execQuery(query, range);
+    }
+
+    RangeResults<TrackId> Track::findIdsWithRecordingMBIDAndMissingFeatures(Session& session, Range range)
+    {
+        session.checkSharedLocked();
+
+        auto query{ session.getDboSession().query<TrackId>("SELECT t.id FROM track t")
+            .where("LENGTH(t.recording_mbid) > 0")
+            .where("NOT EXISTS (SELECT * FROM track_features t_f WHERE t_f.track_id = t.id)") };
+
+        return Utils::execQuery(query, range);
+    }
+
+    std::vector<Cluster::pointer> Track::getClusters() const
+    {
+        return std::vector<Cluster::pointer>(_clusters.begin(), _clusters.end());
+    }
+
+    std::vector<ClusterId> Track::getClusterIds() const
+    {
+        assert(session());
+
+        auto res{ session()->query<ClusterId>
+            ("SELECT DISTINCT c.id FROM cluster c INNER JOIN track_cluster t_c ON t_c.cluster_id = c.id INNER JOIN track t ON t.id = t_c.track_id")
+            .where("t.id = ?").bind(getId())
+            .resultList() };
+
+        return std::vector<ClusterId>(res.begin(), res.end());
+    }
+
+    RangeResults<TrackId> Track::findIds(Session& session, const FindParameters& parameters)
+    {
+        session.checkSharedLocked();
+
+        auto query{ createQuery<TrackId>(session, parameters) };
+        return Utils::execQuery(query, parameters.range);
+    }
+
+    RangeResults<Track::pointer> Track::find(Session& session, const FindParameters& parameters)
+    {
+        session.checkSharedLocked();
+
+        auto query{ createQuery<Wt::Dbo::ptr<Track>>(session, parameters) };
+        return Utils::execQuery(query, parameters.range);
+    }
+
+    RangeResults<TrackId> Track::findSimilarTrackIds(Session& session, const std::vector<TrackId>& tracks, Range range)
+    {
+        assert(!tracks.empty());
+        session.checkSharedLocked();
+
+        std::ostringstream oss;
+        for (std::size_t i{}; i < tracks.size(); ++i)
+        {
+            if (!oss.str().empty())
+                oss << ", ";
+            oss << "?";
+        }
+
+        auto query{ session.getDboSession().query<TrackId>(
+                "SELECT t.id FROM track t"
+                " INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
+                        " AND t_c.cluster_id IN (SELECT DISTINCT c.id FROM cluster c INNER JOIN track_cluster t_c ON t_c.cluster_id = c.id WHERE t_c.track_id IN (" + oss.str() + "))"
+                        " AND t.id NOT IN (" + oss.str() + ")")
+            .groupBy("t.id")
+            .orderBy("COUNT(*) DESC, RANDOM()") };
+
+        for (TrackId trackId : tracks)
+            query.bind(trackId);
+
+        for (TrackId trackId : tracks)
+            query.bind(trackId);
+
+        return Utils::execQuery(query, range);
+    }
+
+    void Track::clearArtistLinks()
+    {
+        _trackArtistLinks.clear();
+    }
+
+    void Track::addArtistLink(const ObjectPtr<TrackArtistLink>& artistLink)
+    {
+        _trackArtistLinks.insert(getDboPtr(artistLink));
+    }
+
+    void Track::setClusters(const std::vector<ObjectPtr<Cluster>>& clusters)
+    {
+        _clusters.clear();
+        for (const ObjectPtr<Cluster>& cluster : clusters)
+            _clusters.insert(getDboPtr(cluster));
+    }
+
+    std::optional<int> Track::getYear() const
+    {
+        return (_date.isValid() ? std::make_optional<int>(_date.year()) : std::nullopt);
+    }
+
+    std::optional<int> Track::getOriginalYear() const
+    {
+        return (_originalDate.isValid() ? std::make_optional<int>(_originalDate.year()) : std::nullopt);
+    }
+
+    std::optional<std::string> Track::getCopyright() const
+    {
+        return _copyright != "" ? std::make_optional<std::string>(_copyright) : std::nullopt;
+    }
+
+    std::optional<std::string> Track::getCopyrightURL() const
+    {
+        return _copyrightURL != "" ? std::make_optional<std::string>(_copyrightURL) : std::nullopt;
+    }
+
+    std::vector<Artist::pointer> Track::getArtists(EnumSet<TrackArtistLinkType> linkTypes) const
+    {
+        assert(session());
+
+        std::ostringstream oss;
+        oss <<
+            "SELECT a from artist a"
+            " INNER JOIN track_artist_link t_a_l ON a.id = t_a_l.artist_id"
+            " INNER JOIN track t ON t.id = t_a_l.track_id";
+
+        if (!linkTypes.empty())
+        {
+            oss << " AND t_a_l.type IN (";
+
+            bool first{ true };
+            for ([[maybe_unused]] TrackArtistLinkType type : linkTypes)
+            {
+                if (!first)
+                    oss << ", ";
+                oss << "?";
+                first = false;
+            }
+            oss << ")";
+        }
+
+        auto query{ session()->query<Wt::Dbo::ptr<Artist>>(oss.str()) };
+        for (TrackArtistLinkType type : linkTypes)
+            query.bind(type);
+
+        query.where("t.id = ?").bind(getId());
+
+        auto res{ query.resultList() };
+        return std::vector<Artist::pointer>(std::begin(res), std::end(res));
+    }
+
+    std::vector<ArtistId> Track::getArtistIds(EnumSet<TrackArtistLinkType> linkTypes) const
+    {
+        assert(self());
+        assert(session());
+
+        std::ostringstream oss;
+        oss <<
+            "SELECT DISTINCT a.id from artist a"
+            " INNER JOIN track_artist_link t_a_l ON a.id = t_a_l.artist_id"
+            " INNER JOIN track t ON t.id = t_a_l.track_id";
+
+        if (!linkTypes.empty())
+        {
+            oss << " AND t_a_l.type IN (";
+
+            bool first{ true };
+            for ([[maybe_unused]] TrackArtistLinkType type : linkTypes)
+            {
+                if (!first)
+                    oss << ", ";
+                oss << "?";
+                first = false;
+            }
+            oss << ")";
+        }
+
+        auto query{ session()->query<ArtistId>(oss.str()) };
+        for (TrackArtistLinkType type : linkTypes)
+            query.bind(type);
+
+        query.where("t.id = ?").bind(getId());
+
+        auto res{ query.resultList() };
+        return std::vector<ArtistId>(std::cbegin(res), std::cend(res));
+    }
+
+    std::vector<TrackArtistLink::pointer> Track::getArtistLinks() const
+    {
+        return std::vector<TrackArtistLink::pointer>(_trackArtistLinks.begin(), _trackArtistLinks.end());
+    }
+
+    std::vector<std::vector<Cluster::pointer>> Track::getClusterGroups(const std::vector<ClusterType::pointer>& clusterTypes, std::size_t size) const
+    {
+        assert(self());
+        assert(session());
+
+        WhereClause where;
+
+        std::ostringstream oss;
+
+        oss << "SELECT c from cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN cluster_type c_type ON c.cluster_type_id = c_type.id";
+
+        where.And(WhereClause("t.id = ?")).bind(getId().toString());
+        {
+            WhereClause clusterClause;
+            for (auto clusterType : clusterTypes)
+                clusterClause.Or(WhereClause("c_type.id = ?")).bind(clusterType->getId().toString());
+            where.And(clusterClause);
+        }
+        oss << " " << where.get();
+        oss << " GROUP BY c.id ORDER BY COUNT(c.id) DESC";
+
+        auto query{ session()->query<Wt::Dbo::ptr<Cluster>>(oss.str()) };
+        for (const std::string& bindArg : where.getBindArgs())
+            query.bind(bindArg);
+
+        auto queryRes{ query.resultList() };
+
+        std::map<ClusterTypeId, std::vector<Cluster::pointer>> clusters;
+        for (const Wt::Dbo::ptr<Cluster>& cluster : queryRes)
+        {
+            if (clusters[cluster->getType()->getId()].size() < size)
+                clusters[cluster->getType()->getId()].push_back(cluster);
+        }
+
+        std::vector<std::vector<Cluster::pointer>> res;
+        for (auto cluster_list : clusters)
+            res.push_back(cluster_list.second);
+
+        return res;
+    }
+
+    namespace Debug
+    {
+        std::ostream& operator<<(std::ostream& os, const TrackInfo& trackInfo)
+        {
+            auto transaction{ trackInfo.session.createSharedTransaction() };
+
+            const Track::pointer track{ Track::find(trackInfo.session, trackInfo.trackId) };
+            if (track)
+            {
+                os << track->getName();
+
+                if (const Release::pointer release{ track->getRelease() })
+                    os << " [" << release->getName() << "]";
+                for (auto artist : track->getArtists({ TrackArtistLinkType::Artist }))
+                    os << " - " << artist->getName();
+                for (auto cluster : track->getClusters())
+                    os << " {" + cluster->getType()->getName() << "-" << cluster->getName() << "}";
+            }
+            else
+            {
+                os << "*unknown*";
+            }
+
+            return os;
+        }
+    }
 
 } // namespace Database
-
diff --git a/src/libs/services/database/impl/TrackList.cpp b/src/libs/services/database/impl/TrackList.cpp
index 227eaa4c..490fc06a 100644
--- a/src/libs/services/database/impl/TrackList.cpp
+++ b/src/libs/services/database/impl/TrackList.cpp
@@ -538,7 +538,7 @@ TrackList::getSimilarTracks(std::optional<std::size_t> offset, std::optional<std
 			"SELECT t FROM track t"
 			" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
 				" WHERE "
-					" (t_c.cluster_id IN (SELECT c.id from cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN tracklist_entry p_e ON p_e.track_id = t.id INNER JOIN tracklist p ON p.id = p_e.tracklist_id WHERE p.id = ?)"
+					" (t_c.cluster_id IN (SELECT DISTINCT c.id from cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN tracklist_entry p_e ON p_e.track_id = t.id INNER JOIN tracklist p ON p.id = p_e.tracklist_id WHERE p.id = ?)"
 					" AND t.id NOT IN (SELECT tracklist_t.id FROM track tracklist_t INNER JOIN tracklist_entry t_e ON t_e.track_id = tracklist_t.id WHERE t_e.tracklist_id = ?))"
 				)
 		.bind(getId())
diff --git a/src/libs/services/database/impl/User.cpp b/src/libs/services/database/impl/User.cpp
index 0661ea69..926b4ac3 100644
--- a/src/libs/services/database/impl/User.cpp
+++ b/src/libs/services/database/impl/User.cpp
@@ -53,8 +53,10 @@ namespace Database {
 
         auto query{ session.getDboSession().query<UserId>("SELECT id FROM user") };
 
-        if (params.scrobbler)
-            query.where("scrobbler = ?").bind(*params.scrobbler);
+        if (params.scrobblingBackend)
+            query.where("scrobbling_backend = ?").bind(*params.scrobblingBackend);
+        if (params.feedbackBackend)
+            query.where("feedback_backend = ?").bind(*params.feedbackBackend);
 
         return Utils::execQuery(query, params.range);
     }
diff --git a/src/libs/services/database/include/services/database/Artist.hpp b/src/libs/services/database/include/services/database/Artist.hpp
index c0c374b3..7fcaadac 100644
--- a/src/libs/services/database/include/services/database/Artist.hpp
+++ b/src/libs/services/database/include/services/database/Artist.hpp
@@ -40,96 +40,97 @@
 namespace Database
 {
 
-class Cluster;
-class ClusterType;
-class Release;
-class Session;
-class StarredArtist;
-class Track;
-class TrackArtistLink;
-class User;
+    class Cluster;
+    class ClusterType;
+    class Release;
+    class Session;
+    class StarredArtist;
+    class Track;
+    class TrackArtistLink;
+    class User;
 
-class Artist final : public Object<Artist, ArtistId>
-{
-	public:
-		struct FindParameters
-		{
-			std::vector<ClusterId>				clusters;	// if non empty, at least one artist that belongs to these clusters
-			std::vector<std::string_view>		keywords;	// if non empty, name must match all of these keywords (on either name field OR sort name field)
-			std::optional<TrackArtistLinkType>	linkType;	// if set, only artists that have produced at least one track with this link type
-			ArtistSortMethod					sortMethod {ArtistSortMethod::None};
-			Range								range;
-			Wt::WDateTime						writtenAfter;
-			UserId								starringUser;	// only artists starred by this user
-			std::optional<Scrobbler>			scrobbler;		// and for this scrobbler
-			TrackId								track;		// artists involved in this track
-			ReleaseId							release;	// artists involved in this release
+    class Artist final : public Object<Artist, ArtistId>
+    {
+    public:
+        struct FindParameters
+        {
+            std::vector<ClusterId>				clusters;	// if non empty, at least one artist that belongs to these clusters
+            std::vector<std::string_view>		keywords;	// if non empty, name must match all of these keywords (on either name field OR sort name field)
+            std::optional<TrackArtistLinkType>	linkType;	// if set, only artists that have produced at least one track with this link type
+            ArtistSortMethod					sortMethod{ ArtistSortMethod::None };
+            Range								range;
+            Wt::WDateTime						writtenAfter;
+            UserId								starringUser;	// only artists starred by this user
+            std::optional<FeedbackBackend>		feedbackBackend; // and for this feedback backend
+            TrackId								track;		// artists involved in this track
+            ReleaseId							release;	// artists involved in this release
 
-			FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; }
-			FindParameters& setKeywords(const std::vector<std::string_view>& _keywords) { keywords = _keywords; return *this; }
-			FindParameters& setLinkType(std::optional<TrackArtistLinkType> _linkType) { linkType = _linkType; return *this; }
-			FindParameters& setSortMethod(ArtistSortMethod _sortMethod) {sortMethod = _sortMethod; return *this; }
-			FindParameters& setRange(Range _range) {range = _range; return *this; }
-			FindParameters& setWrittenAfter(const Wt::WDateTime& _after) { writtenAfter = _after; return *this; }
-			FindParameters& setStarringUser(UserId _user, Scrobbler _scrobbler) { starringUser = _user; scrobbler = _scrobbler; return *this; }
-			FindParameters& setTrack(TrackId _track) { track = _track; return *this; }
-			FindParameters& setRelease(ReleaseId _release) { release = _release; return *this; }
-		};
+            FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; }
+            FindParameters& setKeywords(const std::vector<std::string_view>& _keywords) { keywords = _keywords; return *this; }
+            FindParameters& setLinkType(std::optional<TrackArtistLinkType> _linkType) { linkType = _linkType; return *this; }
+            FindParameters& setSortMethod(ArtistSortMethod _sortMethod) { sortMethod = _sortMethod; return *this; }
+            FindParameters& setRange(Range _range) { range = _range; return *this; }
+            FindParameters& setWrittenAfter(const Wt::WDateTime& _after) { writtenAfter = _after; return *this; }
+            FindParameters& setStarringUser(UserId _user, FeedbackBackend _feedbackBackend) { starringUser = _user; feedbackBackend = _feedbackBackend; return *this; }
+            FindParameters& setTrack(TrackId _track) { track = _track; return *this; }
+            FindParameters& setRelease(ReleaseId _release) { release = _release; return *this; }
+        };
 
-		Artist() = default;
+        Artist() = default;
 
-		// Accessors
-		static std::size_t				getCount(Session& session);
-		static pointer					find(Session& session, const UUID& MBID);
-		static pointer					find(Session& session, ArtistId id);
-		static std::vector<pointer>		find(Session& session, const std::string& name);		// exact match on name field
-		static RangeResults<ArtistId>	find(Session& session, const FindParameters& parameters);
-		static RangeResults<ArtistId>	findAllOrphans(Session& session, Range range); // No track related
-		static bool						exists(Session& session, ArtistId id);
+        // Accessors
+        static std::size_t				getCount(Session& session);
+        static pointer					find(Session& session, const UUID& MBID);
+        static pointer					find(Session& session, ArtistId id);
+        static std::vector<pointer>		find(Session& session, const std::string& name);		// exact match on name field
+        static RangeResults<pointer>	find(Session& session, const FindParameters& parameters);
+        static RangeResults<ArtistId>	findIds(Session& session, const FindParameters& parameters);
+        static RangeResults<ArtistId>	findOrphanIds(Session& session, Range range); // No track related
+        static bool						exists(Session& session, ArtistId id);
 
-		// Accessors
-		const std::string&	getName() const { return _name; }
-		const std::string&	getSortName() const { return _sortName; }
-		std::optional<UUID>	getMBID() const { return UUID::fromString(_MBID); }
+        // Accessors
+        const std::string& getName() const { return _name; }
+        const std::string& getSortName() const { return _sortName; }
+        std::optional<UUID>	getMBID() const { return UUID::fromString(_MBID); }
 
-		// No artistLinkTypes means get them all
-		RangeResults<ArtistId>				findSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes = {}, Range range = {}) const;
+        // No artistLinkTypes means get them all
+        RangeResults<ArtistId>          findSimilarArtistIds(EnumSet<TrackArtistLinkType> artistLinkTypes = {}, Range range = {}) const;
 
-		// Get the cluster of the tracks made by this artist
-		// Each clusters are grouped by cluster type, sorted by the number of occurence
-		// size is the max number of cluster per cluster type
-		std::vector<std::vector<ObjectPtr<Cluster>>> getClusterGroups(std::vector<ObjectPtr<ClusterType>> clusterTypes, std::size_t size) const;
+        // Get the cluster of the tracks made by this artist
+        // Each clusters are grouped by cluster type, sorted by the number of occurence
+        // size is the max number of cluster per cluster type
+        std::vector<std::vector<ObjectPtr<Cluster>>> getClusterGroups(std::vector<ObjectPtr<ClusterType>> clusterTypes, std::size_t size) const;
 
-		void setName(std::string_view name)		{ _name  = name; }
-		void setMBID(const std::optional<UUID>& mbid)	{ _MBID = mbid ? mbid->getAsString() : ""; }
-		void setSortName(const std::string& sortName);
+        void setName(std::string_view name) { _name = name; }
+        void setMBID(const std::optional<UUID>& mbid) { _MBID = mbid ? mbid->getAsString() : ""; }
+        void setSortName(const std::string& sortName);
 
-		template<class Action>
-			void persist(Action& a)
-			{
-				Wt::Dbo::field(a, _name, "name");
-				Wt::Dbo::field(a, _sortName, "sort_name");
-				Wt::Dbo::field(a, _MBID, "mbid");
+        template<class Action>
+        void persist(Action& a)
+        {
+            Wt::Dbo::field(a, _name, "name");
+            Wt::Dbo::field(a, _sortName, "sort_name");
+            Wt::Dbo::field(a, _MBID, "mbid");
 
-				Wt::Dbo::hasMany(a, _trackArtistLinks, Wt::Dbo::ManyToOne, "artist");
-				Wt::Dbo::hasMany(a, _starredArtists, Wt::Dbo::ManyToMany, "user_starred_artists", "", Wt::Dbo::OnDeleteCascade);
-			}
+            Wt::Dbo::hasMany(a, _trackArtistLinks, Wt::Dbo::ManyToOne, "artist");
+            Wt::Dbo::hasMany(a, _starredArtists, Wt::Dbo::ManyToMany, "user_starred_artists", "", Wt::Dbo::OnDeleteCascade);
+        }
 
-	private:
-		static constexpr std::size_t _maxNameLength {128};
+    private:
+        static constexpr std::size_t _maxNameLength{ 128 };
 
-		friend class Session;
-		// Create
-		Artist(const std::string& name, const std::optional<UUID>& MBID = {});
-		static pointer create(Session& session, const std::string& name, const std::optional<UUID>& UUID = {});
+        friend class Session;
+        // Create
+        Artist(const std::string& name, const std::optional<UUID>& MBID = {});
+        static pointer create(Session& session, const std::string& name, const std::optional<UUID>& UUID = {});
 
-		std::string _name;
-		std::string _sortName;
-		std::string _MBID;	// Musicbrainz Identifier
+        std::string _name;
+        std::string _sortName;
+        std::string _MBID;	// Musicbrainz Identifier
 
-		Wt::Dbo::collection<Wt::Dbo::ptr<TrackArtistLink>>	_trackArtistLinks;	// Tracks involving this artist
-		Wt::Dbo::collection<Wt::Dbo::ptr<StarredArtist>>	_starredArtists; 	// starred entries for this artist
-};
+        Wt::Dbo::collection<Wt::Dbo::ptr<TrackArtistLink>>	_trackArtistLinks;	// Tracks involving this artist
+        Wt::Dbo::collection<Wt::Dbo::ptr<StarredArtist>>	_starredArtists; 	// starred entries for this artist
+    };
 
 } // namespace Database
 
diff --git a/src/libs/services/database/include/services/database/Listen.hpp b/src/libs/services/database/include/services/database/Listen.hpp
index 231d763e..20930bc8 100644
--- a/src/libs/services/database/include/services/database/Listen.hpp
+++ b/src/libs/services/database/include/services/database/Listen.hpp
@@ -46,47 +46,50 @@ namespace Database
         struct FindParameters
         {
             UserId							user;
-            std::optional<Scrobbler>		scrobbler;
-            std::optional<ScrobblingState>	scrobblingState;
+            std::optional<ScrobblingBackend>		backend;
+            std::optional<SyncState>	syncState;
             Range							range;
 
             FindParameters& setUser(UserId _user) { user = _user; return *this; }
-            FindParameters& setScrobbler(Scrobbler _scrobbler) { scrobbler = _scrobbler; return *this; }
-            FindParameters& setScrobblingState(ScrobblingState _scrobblingState) { scrobblingState = _scrobblingState; return *this; }
+            FindParameters& setScrobblingBackend(ScrobblingBackend _backend) { backend = _backend; return *this; }
+            FindParameters& setSyncState(SyncState _syncState) { syncState = _syncState; return *this; }
             FindParameters& setRange(Range _range) { range = _range; return *this; }
         };
 
         // Accessors
         static std::size_t              getCount(Session& session);
         static pointer                  find(Session& session, ListenId id);
-        static pointer                  find(Session& session, UserId userId, TrackId trackId, Scrobbler scrobbler, const Wt::WDateTime& dateTime);
+        static pointer                  find(Session& session, UserId userId, TrackId trackId, ScrobblingBackend backend, const Wt::WDateTime& dateTime);
         static RangeResults<ListenId>   find(Session& session, const FindParameters& parameters);
 
         // Stats
-        static RangeResults<ArtistId>   getTopArtists(Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, Range range = {});
-        static RangeResults<ReleaseId>  getTopReleases(Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, Range range = {});
-        static RangeResults<TrackId>    getTopTracks(Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, Range range = {});
+        static RangeResults<ArtistId>   getTopArtists(Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, Range range = {});
+        static RangeResults<ReleaseId>  getTopReleases(Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, Range range = {});
+        static RangeResults<TrackId>    getTopTracks(Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, Range range = {});
 
-        static RangeResults<ArtistId>   getRecentArtists(Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, Range range = {});
-        static RangeResults<ReleaseId>  getRecentReleases(Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, Range range = {});
-        static RangeResults<TrackId>    getRecentTracks(Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, Range range = {});
+        static RangeResults<ArtistId>   getRecentArtists(Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, Range range = {});
+        static RangeResults<ReleaseId>  getRecentReleases(Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, Range range = {});
+        static RangeResults<TrackId>    getRecentTracks(Session& session, UserId userId, ScrobblingBackend backend, const std::vector<ClusterId>& clusterIds, Range range = {});
 
-        static pointer          getMostRecentListen(Session& session, UserId userId, Scrobbler scrobbler, ReleaseId releaseId);
-        static pointer          getMostRecentListen(Session& session, UserId userId, Scrobbler scrobbler, TrackId releaseId);
+        static std::size_t              getCount(Session& session, UserId userId, ScrobblingBackend backend, TrackId trackId);
+        static std::size_t              getCount(Session& session, UserId userId, ScrobblingBackend backend, ReleaseId trackId);
 
-        ScrobblingState         getScrobblingState() const { return _scrobblingState; }
+        static pointer          getMostRecentListen(Session& session, UserId userId, ScrobblingBackend backend, ReleaseId releaseId);
+        static pointer          getMostRecentListen(Session& session, UserId userId, ScrobblingBackend backend, TrackId releaseId);
+
+        SyncState               getSyncState() const { return _syncState; }
         ObjectPtr<User>         getUser() const { return _user; }
         ObjectPtr<Track>        getTrack() const { return _track; }
         const Wt::WDateTime& getDateTime() const { return _dateTime; }
 
-        void			setScrobblingState(ScrobblingState state) { _scrobblingState = state; }
+        void			setSyncState(SyncState state) { _syncState = state; }
 
         template<class Action>
         void persist(Action& a)
         {
             Wt::Dbo::field(a, _dateTime, "date_time");
-            Wt::Dbo::field(a, _scrobbler, "scrobbler");
-            Wt::Dbo::field(a, _scrobblingState, "scrobbling_state");
+            Wt::Dbo::field(a, _backend, "backend"); // TODO rename
+            Wt::Dbo::field(a, _syncState, "sync_state"); // TODO rename
 
             Wt::Dbo::belongsTo(a, _track, "track", Wt::Dbo::OnDeleteCascade);
             Wt::Dbo::belongsTo(a, _user, "user", Wt::Dbo::OnDeleteCascade);
@@ -94,12 +97,12 @@ namespace Database
 
     private:
         friend class Session;
-        Listen(ObjectPtr<User> user, ObjectPtr<Track> track, Scrobbler scrobbler, const Wt::WDateTime& dateTime);
-        static pointer create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track, Scrobbler scrobbler, const Wt::WDateTime& dateTime);
+        Listen(ObjectPtr<User> user, ObjectPtr<Track> track, ScrobblingBackend backend, const Wt::WDateTime& dateTime);
+        static pointer create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track, ScrobblingBackend backend, const Wt::WDateTime& dateTime);
 
-        Wt::WDateTime		_dateTime;
-        Scrobbler			_scrobbler;
-        ScrobblingState		_scrobblingState{ ScrobblingState::PendingAdd };
+        Wt::WDateTime       _dateTime;
+        ScrobblingBackend   _backend;
+        SyncState           _syncState{ SyncState::PendingAdd };
 
         Wt::Dbo::ptr<User>	_user;
         Wt::Dbo::ptr<Track>	_track;
diff --git a/src/libs/services/database/include/services/database/Release.hpp b/src/libs/services/database/include/services/database/Release.hpp
index a9c39b07..28035a38 100644
--- a/src/libs/services/database/include/services/database/Release.hpp
+++ b/src/libs/services/database/include/services/database/Release.hpp
@@ -57,7 +57,7 @@ namespace Database
             Wt::WDateTime                       writtenAfter;
             std::optional<DateRange>            dateRange;
             UserId                              starringUser;				// only releases starred by this user
-            std::optional<Scrobbler>            scrobbler;					//    and for this scrobbler
+            std::optional<FeedbackBackend>      feedbackBackend;		    //    and for this backend
             ArtistId                            artist;						// only releases that involved this user
             EnumSet<TrackArtistLinkType>        trackArtistLinkTypes; 			//    and for these link types
             EnumSet<TrackArtistLinkType>        excludedTrackArtistLinkTypes; 	//    but not for these link types
@@ -70,7 +70,7 @@ namespace Database
             FindParameters& setRange(Range _range) { range = _range; return *this; }
             FindParameters& setWrittenAfter(const Wt::WDateTime& _after) { writtenAfter = _after; return *this; }
             FindParameters& setDateRange(const std::optional<DateRange>& _dateRange) { dateRange = _dateRange; return *this; }
-            FindParameters& setStarringUser(UserId _user, Scrobbler _scrobbler) { starringUser = _user; scrobbler = _scrobbler; return *this; }
+            FindParameters& setStarringUser(UserId _user, FeedbackBackend _feedbackBackend) { starringUser = _user; feedbackBackend = _feedbackBackend; return *this; }
             FindParameters& setArtist(ArtistId _artist, EnumSet<TrackArtistLinkType> _trackArtistLinkTypes = {}, EnumSet<TrackArtistLinkType> _excludedTrackArtistLinkTypes = {})
             {
                 artist = _artist;
@@ -88,9 +88,10 @@ namespace Database
         static pointer                  find(Session& session, const UUID& MBID);
         static std::vector<pointer>     find(Session& session, const std::string& name);
         static pointer                  find(Session& session, ReleaseId id);
-        static RangeResults<ReleaseId>  find(Session& session, const FindParameters& parameters);
-        static RangeResults<ReleaseId>  findOrphans(Session& session, Range range); // no track related
-        static RangeResults<ReleaseId>  findOrderedByArtist(Session& session, Range range);
+        static RangeResults<pointer>    find(Session& session, const FindParameters& parameters);
+        static RangeResults<ReleaseId>  findIds(Session& session, const FindParameters& parameters);
+        static RangeResults<ReleaseId>  findOrphanIds(Session& session, Range range); // not track related
+        static RangeResults<ReleaseId>  findIdsOrderedByArtist(Session& session, Range range);
 
         // Get the cluster of the tracks that belong to this release
         // Each clusters are grouped by cluster type, sorted by the number of occurence (max to min)
@@ -104,7 +105,7 @@ namespace Database
         std::optional<std::string>  getCopyrightURL() const;
 
         // Accessors
-        const std::string&                  getName() const { return _name; }
+        const std::string& getName() const { return _name; }
         std::optional<UUID>                 getMBID() const { return UUID::fromString(_MBID); }
         std::optional<std::size_t>          getTotalDisc() const { return _totalDisc; }
         std::size_t                         getDiscCount() const; // may not be total disc (if incomplete for example)
diff --git a/src/libs/services/database/include/services/database/ScanSettings.hpp b/src/libs/services/database/include/services/database/ScanSettings.hpp
index bb9c924a..cf2aa26b 100644
--- a/src/libs/services/database/include/services/database/ScanSettings.hpp
+++ b/src/libs/services/database/include/services/database/ScanSettings.hpp
@@ -32,72 +32,74 @@ LMS_DECLARE_IDTYPE(ScanSettingsId)
 
 namespace Database {
 
-class ClusterType;
-class Session;
+    class ClusterType;
+    class Session;
 
-class ScanSettings final : public Object<ScanSettings, ScanSettingsId>
-{
-	public:
-		// Do not modify values (just add)
-		enum class UpdatePeriod
-		{
-			Never = 0,
-			Daily,
-			Weekly,
-			Monthly,
-			Hourly,
-		};
+    class ScanSettings final : public Object<ScanSettings, ScanSettingsId>
+    {
+    public:
+        // Do not modify values (just add)
+        enum class UpdatePeriod
+        {
+            Never = 0,
+            Daily,
+            Weekly,
+            Monthly,
+            Hourly,
+        };
 
-		// Do not modify values (just add)
-		enum class RecommendationEngineType
-		{
-			Clusters = 0,
-			Features,
-		};
+        // Do not modify values (just add)
+        enum class SimilarityEngineType
+        {
+            Clusters = 0,
+            Features,
+            None,
+        };
 
-		static void init(Session& session);
+        static void init(Session& session);
 
-		static pointer get(Session& session);
+        static pointer get(Session& session);
 
-		// Getters
-		std::size_t				getScanVersion() const { return _scanVersion; }
-		std::filesystem::path	getMediaDirectory() const { return _mediaDirectory; }
-		Wt::WTime				getUpdateStartTime() const { return _startTime; }
-		UpdatePeriod			getUpdatePeriod() const { return _updatePeriod; }
-		std::vector<ObjectPtr<ClusterType>> getClusterTypes() const;
-		std::vector<std::filesystem::path> getAudioFileExtensions() const;
-		RecommendationEngineType	getRecommendationEngineType() const { return _recommendationEngineType; }
+        // Getters
+        std::size_t				getScanVersion() const { return _scanVersion; }
+        std::filesystem::path	getMediaDirectory() const { return _mediaDirectory; }
+        Wt::WTime				getUpdateStartTime() const { return _startTime; }
+        UpdatePeriod			getUpdatePeriod() const { return _updatePeriod; }
+        std::vector<ObjectPtr<ClusterType>> getClusterTypes() const;
+        std::vector<std::filesystem::path> getAudioFileExtensions() const;
+        SimilarityEngineType	getSimilarityEngineType() const { return _similarityEngineType; }
 
-		// Setters
-		void addAudioFileExtension(const std::filesystem::path& ext);
-		void setMediaDirectory(const std::filesystem::path& p);
-		void setUpdateStartTime(Wt::WTime t) { _startTime = t; }
-		void setUpdatePeriod(UpdatePeriod p) { _updatePeriod = p; }
-		void setClusterTypes(Session& session, const std::set<std::string>& clusterTypeNames);
-		void setRecommendationEngineType(RecommendationEngineType type) { _recommendationEngineType = type; }
-		void incScanVersion();
+        // Setters
+        void addAudioFileExtension(const std::filesystem::path& ext);
+        void setMediaDirectory(const std::filesystem::path& p);
+        void setUpdateStartTime(Wt::WTime t) { _startTime = t; }
+        void setUpdatePeriod(UpdatePeriod p) { _updatePeriod = p; }
+        void setClusterTypes(Session& session, const std::set<std::string>& clusterTypeNames);
+        void setSimilarityEngineType(SimilarityEngineType type) { _similarityEngineType = type; }
+        void incScanVersion();
 
-		template<class Action>
-		void persist(Action& a)
-		{
-			Wt::Dbo::field(a, _scanVersion,		"scan_version");
-			Wt::Dbo::field(a, _mediaDirectory,	"media_directory");
-			Wt::Dbo::field(a, _startTime,		"start_time");
-			Wt::Dbo::field(a, _updatePeriod,	"update_period");
-			Wt::Dbo::field(a, _audioFileExtensions,	"audio_file_extensions");
-			Wt::Dbo::field(a, _recommendationEngineType,"similarity_engine_type");
-			Wt::Dbo::hasMany(a, _clusterTypes, Wt::Dbo::ManyToOne, "scan_settings");
-		}
+        template<class Action>
+        void persist(Action& a)
+        {
+            Wt::Dbo::field(a, _scanVersion, "scan_version");
+            Wt::Dbo::field(a, _mediaDirectory, "media_directory");
+            Wt::Dbo::field(a, _startTime, "start_time");
+            Wt::Dbo::field(a, _updatePeriod, "update_period");
+            Wt::Dbo::field(a, _audioFileExtensions, "audio_file_extensions");
+            Wt::Dbo::field(a, _similarityEngineType, "similarity_engine_type");
+            Wt::Dbo::hasMany(a, _clusterTypes, Wt::Dbo::ManyToOne, "scan_settings");
+        }
 
-	private:
-		int		_scanVersion {};
-		std::string	_mediaDirectory;
-		Wt::WTime	_startTime = Wt::WTime {0,0,0};
-		UpdatePeriod	_updatePeriod {UpdatePeriod::Never};
-		RecommendationEngineType _recommendationEngineType {RecommendationEngineType::Clusters};
-		std::string	_audioFileExtensions {".alac .mp3 .ogg .oga .aac .m4a .m4b .flac .wav .wma .aif .aiff .ape .mpc .shn .opus .wv"};
-		Wt::Dbo::collection<Wt::Dbo::ptr<ClusterType>>	_clusterTypes;
-};
+    private:
+        int         	_scanVersion{};
+        std::string     _mediaDirectory;
+        Wt::WTime       _startTime = Wt::WTime{ 0,0,0 };
+        UpdatePeriod    _updatePeriod{ UpdatePeriod::Never };
+        SimilarityEngineType    _similarityEngineType{ SimilarityEngineType::Clusters };
+        std::string             _audioFileExtensions{ ".alac .mp3 .ogg .oga .aac .m4a .m4b .flac .wav .wma .aif .aiff .ape .mpc .shn .opus .wv" };
+        
+        Wt::Dbo::collection<Wt::Dbo::ptr<ClusterType>>	_clusterTypes;
+    };
 
 
 } // namespace Database
diff --git a/src/libs/services/database/include/services/database/Session.hpp b/src/libs/services/database/include/services/database/Session.hpp
index 2b36e97d..504b516a 100644
--- a/src/libs/services/database/include/services/database/Session.hpp
+++ b/src/libs/services/database/include/services/database/Session.hpp
@@ -61,6 +61,7 @@ namespace Database
         void checkSharedLocked();
 
         void analyze();
+        void optimize();
 
         void prepareTables(); // need to run only once at startup
 
diff --git a/src/libs/services/database/include/services/database/StarredArtist.hpp b/src/libs/services/database/include/services/database/StarredArtist.hpp
index b4f48b6b..1d02eaf5 100644
--- a/src/libs/services/database/include/services/database/StarredArtist.hpp
+++ b/src/libs/services/database/include/services/database/StarredArtist.hpp
@@ -30,53 +30,53 @@
 
 namespace Database
 {
-	class Artist;
-	class Session;
-	class User;
+    class Artist;
+    class Session;
+    class User;
 
-	class StarredArtist final : public Object<StarredArtist, StarredArtistId>
-	{
-		public:
-			StarredArtist() = default;
+    class StarredArtist final : public Object<StarredArtist, StarredArtistId>
+    {
+    public:
+        StarredArtist() = default;
 
-			// Search utility
-			static std::size_t	getCount(Session& session);
-			static pointer		find(Session& session, StarredArtistId id);
-			static pointer		find(Session& session, ArtistId artistId, UserId userId, Scrobbler scrobbler);
+        // Search utility
+        static std::size_t	getCount(Session& session);
+        static pointer		find(Session& session, StarredArtistId id);
+        static pointer		find(Session& session, ArtistId artistId, UserId userId, FeedbackBackend backend);
 
-			// Accessors
-			ObjectPtr<Artist>	getArtist() const { return _artist; }
-			ObjectPtr<User>		getUser() const { return _user; }
-			Scrobbler			getScrobbler() const { return _scrobbler; }
-			const Wt::WDateTime& getDateTime() const { return _dateTime; }
-			ScrobblingState		getScrobblingState() const { return _scrobblingState; }
+        // Accessors
+        ObjectPtr<Artist>	getArtist() const { return _artist; }
+        ObjectPtr<User>		getUser() const { return _user; }
+        FeedbackBackend	    getFeedbackBackend() const { return _backend; }
+        const Wt::WDateTime& getDateTime() const { return _dateTime; }
+        SyncState			getSyncState() const { return _syncState; }
 
-			// Setters
-			void setDateTime(const Wt::WDateTime& dateTime);
-			void setScrobblingState(ScrobblingState state) { _scrobblingState  = state; }
+        // Setters
+        void setDateTime(const Wt::WDateTime& dateTime);
+        void setSyncState(SyncState state) { _syncState = state; }
 
-			template<class Action>
-			void persist(Action& a)
-			{
-				Wt::Dbo::field(a,	_scrobbler,			"scrobbler");
-				Wt::Dbo::field(a,	_scrobblingState,	"scrobbling_state");
-				Wt::Dbo::field(a,	_dateTime,			"date_time");
+        template<class Action>
+        void persist(Action& a)
+        {
+            Wt::Dbo::field(a, _backend, "backend");
+            Wt::Dbo::field(a, _syncState, "sync_state");
+            Wt::Dbo::field(a, _dateTime, "date_time");
 
-				Wt::Dbo::belongsTo(a,	_artist,	"artist",	Wt::Dbo::OnDeleteCascade);
-				Wt::Dbo::belongsTo(a,	_user,		"user",		Wt::Dbo::OnDeleteCascade);
-			}
+            Wt::Dbo::belongsTo(a, _artist, "artist", Wt::Dbo::OnDeleteCascade);
+            Wt::Dbo::belongsTo(a, _user, "user", Wt::Dbo::OnDeleteCascade);
+        }
 
-		private:
-			friend class Session;
-			StarredArtist(ObjectPtr<Artist> artist, ObjectPtr<User> user, Scrobbler scrobbler);
-			static pointer create(Session& session, ObjectPtr<Artist> artist, ObjectPtr<User> user, Scrobbler scrobbler);
+    private:
+        friend class Session;
+        StarredArtist(ObjectPtr<Artist> artist, ObjectPtr<User> user, FeedbackBackend scrobblingbackend);
+        static pointer create(Session& session, ObjectPtr<Artist> artist, ObjectPtr<User> user, FeedbackBackend scrobblingbackend);
 
-			Scrobbler		_scrobbler;			// for which scrobbler
-			ScrobblingState	_scrobblingState {ScrobblingState::PendingAdd};
-			Wt::WDateTime	_dateTime;			// when it was starred
+        FeedbackBackend     _backend;			// for which backend
+        SyncState           _syncState{ SyncState::PendingAdd };
+        Wt::WDateTime       _dateTime;			// when it was starred
 
-			Wt::Dbo::ptr<Artist>	_artist;
-			Wt::Dbo::ptr<User>		_user;
-	};
+        Wt::Dbo::ptr<Artist>    _artist;
+        Wt::Dbo::ptr<User>      _user;
+    };
 } // namespace Database
 
diff --git a/src/libs/services/database/include/services/database/StarredRelease.hpp b/src/libs/services/database/include/services/database/StarredRelease.hpp
index f3b4280a..23d4116e 100644
--- a/src/libs/services/database/include/services/database/StarredRelease.hpp
+++ b/src/libs/services/database/include/services/database/StarredRelease.hpp
@@ -30,53 +30,53 @@
 
 namespace Database
 {
-	class Release;
-	class Session;
-	class User;
+    class Release;
+    class Session;
+    class User;
 
-	class StarredRelease final : public Object<StarredRelease, StarredReleaseId>
-	{
-		public:
-			StarredRelease() = default;
+    class StarredRelease final : public Object<StarredRelease, StarredReleaseId>
+    {
+    public:
+        StarredRelease() = default;
 
-			// Search utility
-			static std::size_t	getCount(Session& session);
-			static pointer		find(Session& session, StarredReleaseId id);
-			static pointer		find(Session& session, ReleaseId releaseId, UserId userId, Scrobbler scrobbler);
+        // Search utility
+        static std::size_t getCount(Session& session);
+        static pointer find(Session& session, StarredReleaseId id);
+        static pointer find(Session& session, ReleaseId releaseId, UserId userId, FeedbackBackend backend);
 
-			// Accessors
-			ObjectPtr<Release>	getRelease() const { return _release; }
-			ObjectPtr<User>		getUser() const { return _user; }
-			Scrobbler			getScrobbler() const { return _scrobbler; }
-			const Wt::WDateTime& getDateTime() const { return _dateTime; }
-			ScrobblingState		getScrobblingState() const { return _scrobblingState; }
+        // Accessors
+        ObjectPtr<Release> getRelease() const { return _release; }
+        ObjectPtr<User>    getUser() const { return _user; }
+        FeedbackBackend  getFeedbackBackend() const { return _backend; }
+        const Wt::WDateTime& getDateTime() const { return _dateTime; }
+        SyncState getSyncState() const { return _syncState; }
 
-			// Setters
-			void setDateTime(const Wt::WDateTime& dateTime);
-			void setScrobblingState(ScrobblingState state) { _scrobblingState  = state; }
+        // Setters
+        void setDateTime(const Wt::WDateTime& dateTime);
+        void setSyncState(SyncState state) { _syncState = state; }
 
-			template<class Action>
-			void persist(Action& a)
-			{
-				Wt::Dbo::field(a,	_scrobbler,			"scrobbler");
-				Wt::Dbo::field(a,	_scrobblingState,	"scrobbling_state");
-				Wt::Dbo::field(a,	_dateTime,			"date_time");
+        template<class Action>
+        void persist(Action& a)
+        {
+            Wt::Dbo::field(a, _backend, "backend");
+            Wt::Dbo::field(a, _syncState, "sync_state");
+            Wt::Dbo::field(a, _dateTime, "date_time");
 
-				Wt::Dbo::belongsTo(a,	_release,	"release",	Wt::Dbo::OnDeleteCascade);
-				Wt::Dbo::belongsTo(a,	_user,		"user",		Wt::Dbo::OnDeleteCascade);
-			}
+            Wt::Dbo::belongsTo(a, _release, "release", Wt::Dbo::OnDeleteCascade);
+            Wt::Dbo::belongsTo(a, _user, "user", Wt::Dbo::OnDeleteCascade);
+        }
 
-		private:
-			friend class Session;
-			StarredRelease(ObjectPtr<Release> release, ObjectPtr<User> user, Scrobbler scrobbler);
-			static pointer create(Session& session, ObjectPtr<Release> release, ObjectPtr<User> user, Scrobbler scrobbler);
+    private:
+        friend class Session;
+        StarredRelease(ObjectPtr<Release> release, ObjectPtr<User> user, FeedbackBackend backend);
+        static pointer create(Session& session, ObjectPtr<Release> release, ObjectPtr<User> user, FeedbackBackend backend);
 
-			Scrobbler		_scrobbler;			// for which scrobbler
-			ScrobblingState	_scrobblingState {ScrobblingState::PendingAdd};
-			Wt::WDateTime	_dateTime;			// when it was starred
+        FeedbackBackend		_backend;			// for which backend
+        SyncState	_syncState{ SyncState::PendingAdd };
+        Wt::WDateTime	_dateTime;			// when it was starred
 
-			Wt::Dbo::ptr<Release>	_release;
-			Wt::Dbo::ptr<User>		_user;
-	};
+        Wt::Dbo::ptr<Release>	_release;
+        Wt::Dbo::ptr<User>		_user;
+    };
 } // namespace Database
 
diff --git a/src/libs/services/database/include/services/database/StarredTrack.hpp b/src/libs/services/database/include/services/database/StarredTrack.hpp
index 197c88c1..7b3e50f7 100644
--- a/src/libs/services/database/include/services/database/StarredTrack.hpp
+++ b/src/libs/services/database/include/services/database/StarredTrack.hpp
@@ -31,66 +31,66 @@
 
 namespace Database
 {
-	class Track;
-	class Session;
-	class User;
+    class Track;
+    class Session;
+    class User;
 
-	class StarredTrack final : public Object<StarredTrack, StarredTrackId>
-	{
-		public:
-			StarredTrack() = default;
+    class StarredTrack final : public Object<StarredTrack, StarredTrackId>
+    {
+    public:
+        StarredTrack() = default;
 
-			struct FindParameters
-			{
-				std::optional<Scrobbler>    	scrobbler;      	// for this scrobbler
-				std::optional<ScrobblingState>	scrobblingState;	//   and these states
-				UserId							user;				// and this user
-				Range							range;
+        struct FindParameters
+        {
+            std::optional<FeedbackBackend>  backend;    // for this backend
+            std::optional<SyncState>	    syncState;  //   and these states
+            UserId							user;       // and this user
+            Range							range;
 
-				FindParameters& setScrobbler(Scrobbler _scrobbler, ScrobblingState _scrobblingState) { scrobbler = _scrobbler; scrobblingState = _scrobblingState; return *this; }
-				FindParameters& setUser(UserId _user) {user = _user; return *this; }
-				FindParameters& setRange(Range _range) {range = _range; return *this; }
-			};
+            FindParameters& setFeedbackBackend(FeedbackBackend _backend, SyncState _syncState) { backend = _backend; syncState = _syncState; return *this; }
+            FindParameters& setUser(UserId _user) { user = _user; return *this; }
+            FindParameters& setRange(Range _range) { range = _range; return *this; }
+        };
 
-			// Search utility
-			static std::size_t	getCount(Session& session);
-			static pointer		find(Session& session, StarredTrackId id);
-			static pointer		find(Session& session, TrackId trackId, UserId userId, Scrobbler scrobbler);
-			static RangeResults<StarredTrackId>	find(Session& session, const FindParameters& findParams);
+        // Search utility
+        static std::size_t  getCount(Session& session);
+        static pointer      find(Session& session, StarredTrackId id);
+        static pointer      find(Session& session, TrackId trackId, UserId userId, FeedbackBackend backend);
+        static RangeResults<StarredTrackId>	find(Session& session, const FindParameters& findParams);
 
-			// Accessors
-			ObjectPtr<Track>	getTrack() const { return _track; }
-			ObjectPtr<User>		getUser() const { return _user; }
-			Scrobbler			getScrobbler() const { return _scrobbler; }
-			const Wt::WDateTime& getDateTime() const { return _dateTime; }
-			ScrobblingState		getScrobblingState() const { return _scrobblingState; }
+        // Accessors
+        ObjectPtr<Track>        getTrack() const { return _track; }
+        ObjectPtr<User>         getUser() const { return _user; }
+        FeedbackBackend         getBackend() const { return _backend; }
+        const Wt::WDateTime& getDateTime() const { return _dateTime; }
+        SyncState               getSyncState() const { return _syncState; }
 
-			// Setters
-			void setDateTime(const Wt::WDateTime& dateTime);
-			void setScrobblingState(ScrobblingState state) { _scrobblingState  = state; }
+        // Setters
+        void setDateTime(const Wt::WDateTime& dateTime);
+        void setSyncState(SyncState state) { _syncState = state; }
 
-			template<class Action>
-			void persist(Action& a)
-			{
-				Wt::Dbo::field(a,	_scrobbler,			"scrobbler");
-				Wt::Dbo::field(a,	_scrobblingState,	"scrobbling_state");
-				Wt::Dbo::field(a,	_dateTime,			"date_time");
+        template<class Action>
+        void persist(Action& a)
+        {
+            Wt::Dbo::field(a, _backend, "backend");
+            Wt::Dbo::field(a, _syncState, "sync_state");
+            Wt::Dbo::field(a, _dateTime, "date_time");
 
-				Wt::Dbo::belongsTo(a,	_track,		"track",	Wt::Dbo::OnDeleteCascade);
-				Wt::Dbo::belongsTo(a,	_user,		"user",		Wt::Dbo::OnDeleteCascade);
-			}
+            Wt::Dbo::belongsTo(a, _track, "track", Wt::Dbo::OnDeleteCascade);
+            Wt::Dbo::belongsTo(a, _user, "user", Wt::Dbo::OnDeleteCascade);
+        }
 
-		private:
-			friend class Session;
-			StarredTrack(ObjectPtr<Track> track, ObjectPtr<User> user, Scrobbler scrobbler);
-			static pointer create(Session& session, ObjectPtr<Track> track, ObjectPtr<User> user, Scrobbler scrobbler);
+    private:
+        friend class Session;
+        StarredTrack(ObjectPtr<Track> track, ObjectPtr<User> user, FeedbackBackend backend);
+        static pointer create(Session& session, ObjectPtr<Track> track, ObjectPtr<User> user, FeedbackBackend backend);
 
-			Scrobbler		_scrobbler;			// for which scrobbler
-			ScrobblingState	_scrobblingState {ScrobblingState::PendingAdd};
-			Wt::WDateTime	_dateTime;			// when it was starred
+        FeedbackBackend     _backend;   // for which backend
+        SyncState           _syncState{ SyncState::PendingAdd };
+        Wt::WDateTime       _dateTime;  // when it was starred
 
-			Wt::Dbo::ptr<Track>		_track;
-			Wt::Dbo::ptr<User>		_user;
-	};
+        Wt::Dbo::ptr<Track> _track;
+        Wt::Dbo::ptr<User>  _user;
+    };
 } // namespace Database
 
diff --git a/src/libs/services/database/include/services/database/Track.hpp b/src/libs/services/database/include/services/database/Track.hpp
index 94401a61..e15aaf1e 100644
--- a/src/libs/services/database/include/services/database/Track.hpp
+++ b/src/libs/services/database/include/services/database/Track.hpp
@@ -21,11 +21,10 @@
 
 #include <chrono>
 #include <filesystem>
-#include <iostream>
+#include <ostream>
 #include <optional>
 #include <string>
 #include <string_view>
-#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -61,23 +60,23 @@ class Track final : public Object<Track, TrackId>
 	public:
 		struct FindParameters
 		{
-			std::vector<ClusterId>			clusters;		// if non empty, tracks that belong to these clusters
-			std::vector<std::string_view>	keywords;		// if non empty, name must match all of these keywords
-			std::string						name;			// if non empty, must match this name
-			TrackSortMethod					sortMethod {TrackSortMethod::None};
-			Range							range;
-			Wt::WDateTime					writtenAfter;
-			UserId							starringUser;	// only tracks starred by this user
-			std::optional<Scrobbler>		scrobbler;		// and for this scrobbler
-			ArtistId						artist;			// only tracks that involve this artist
-			std::string						artistName;		// only tracks that involve this artist name
-			EnumSet<TrackArtistLinkType>	trackArtistLinkTypes; 		//    and for these link types
-			bool							nonRelease {};	// only tracks that do not belong to a release
-			ReleaseId						release;		// matching this release
-			std::string						releaseName;	// matching this release name
-			TrackListId						trackList;		// matching this trackList
-			std::optional<int>				trackNumber;	// matching this track number
-			bool							distinct {true};
+			std::vector<ClusterId>				clusters;		// if non empty, tracks that belong to these clusters
+			std::vector<std::string_view>		keywords;		// if non empty, name must match all of these keywords
+			std::string							name;			// if non empty, must match this name
+			TrackSortMethod						sortMethod {TrackSortMethod::None};
+			Range								range;
+			Wt::WDateTime						writtenAfter;
+			UserId								starringUser;	// only tracks starred by this user
+			std::optional<FeedbackBackend>		feedbackBackend;	// and for this feedback backend
+			ArtistId							artist;			// only tracks that involve this artist
+			std::string							artistName;		// only tracks that involve this artist name
+			EnumSet<TrackArtistLinkType>		trackArtistLinkTypes; 		//    and for these link types
+			bool								nonRelease {};	// only tracks that do not belong to a release
+			ReleaseId							release;		// matching this release
+			std::string							releaseName;	// matching this release name
+			TrackListId							trackList;		// matching this trackList
+			std::optional<int>					trackNumber;	// matching this track number
+			bool								distinct {true};
 
 			FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; }
 			FindParameters& setKeywords(const std::vector<std::string_view>& _keywords) { keywords = _keywords; return *this; }
@@ -85,7 +84,7 @@ class Track final : public Object<Track, TrackId>
 			FindParameters& setSortMethod(TrackSortMethod _method) { sortMethod = _method; return *this; }
 			FindParameters& setRange(Range _range) { range = _range; return *this; }
 			FindParameters& setWrittenAfter(const Wt::WDateTime& _after) { writtenAfter = _after; return *this; }
-			FindParameters& setStarringUser(UserId _user, Scrobbler _scrobbler) { starringUser = _user; scrobbler = _scrobbler; return *this; }
+			FindParameters& setStarringUser(UserId _user, FeedbackBackend _feedbackBackend) { starringUser = _user; feedbackBackend = _feedbackBackend; return *this; }
 			FindParameters& setArtist(ArtistId _artist, EnumSet<TrackArtistLinkType> _trackArtistLinkTypes = {}) { artist = _artist; trackArtistLinkTypes = _trackArtistLinkTypes; return *this; }
 			FindParameters& setArtistName(std::string_view _artistName, EnumSet<TrackArtistLinkType> _trackArtistLinkTypes = {}) { artistName = _artistName; trackArtistLinkTypes = _trackArtistLinkTypes; return *this; }
 			FindParameters& setNonRelease(bool _nonRelease) { nonRelease = _nonRelease; return *this; }
@@ -111,12 +110,13 @@ class Track final : public Object<Track, TrackId>
 		static bool						exists(Session& session, TrackId id);
 		static std::vector<pointer>		findByRecordingMBID(Session& session, const UUID& MBID);
 		static std::vector<pointer>		findByMBID(Session& session, const UUID& MBID);
-		static RangeResults<TrackId>	findSimilarTracks(Session& session, const std::vector<TrackId>& trackIds, Range range);
+		static RangeResults<TrackId>	findSimilarTrackIds(Session& session, const std::vector<TrackId>& trackIds, Range range);
 
-		static RangeResults<TrackId>	find(Session& session, const FindParameters& parameters);
+		static RangeResults<TrackId>	findIds(Session& session, const FindParameters& parameters);
+		static RangeResults<pointer>	find(Session& session, const FindParameters& parameters);
 		static RangeResults<PathResult>	findPaths(Session& session, Range range);
-		static RangeResults<TrackId>	findTrackMBIDDuplicates(Session& session, Range range);
-		static RangeResults<TrackId>	findWithRecordingMBIDAndMissingFeatures(Session& session, Range range);
+		static RangeResults<TrackId>	findIdsTrackMBIDDuplicates(Session& session, Range range);
+		static RangeResults<TrackId>	findIdsWithRecordingMBIDAndMissingFeatures(Session& session, Range range);
 
 		// Accessors
 		void setScanVersion(std::size_t version)				{ _scanVersion = version; }
diff --git a/src/libs/services/database/include/services/database/Types.hpp b/src/libs/services/database/include/services/database/Types.hpp
index 3266c582..a07ec274 100644
--- a/src/libs/services/database/include/services/database/Types.hpp
+++ b/src/libs/services/database/include/services/database/Types.hpp
@@ -46,7 +46,7 @@ namespace Database
 	{
 		Range range;
 		std::vector<T> results;
-		bool moreResults;
+		bool moreResults{};
 
 		RangeResults getSubRange(Range subRange)
 		{
@@ -160,13 +160,19 @@ namespace Database
 	void visitAllowedAudioBitrates(std::function<void(Bitrate)>);
 	bool isAudioBitrateAllowed(Bitrate bitrate);
 
-	enum class Scrobbler
+	enum class ScrobblingBackend
 	{
 		Internal		= 0,
 		ListenBrainz	= 1,
 	};
 
-	enum class ScrobblingState
+	enum class FeedbackBackend
+	{
+		Internal		= 0,
+		ListenBrainz	= 1,
+	};
+
+	enum class SyncState
 	{
 		PendingAdd		= 0,
 		Synchronized	= 1,
diff --git a/src/libs/services/database/include/services/database/User.hpp b/src/libs/services/database/include/services/database/User.hpp
index 5a3bd8ee..f177120f 100644
--- a/src/libs/services/database/include/services/database/User.hpp
+++ b/src/libs/services/database/include/services/database/User.hpp
@@ -47,20 +47,23 @@ namespace Database {
 
         struct FindParameters
         {
-            std::optional<Scrobbler>		scrobbler;
-            Range							range;
+            std::optional<ScrobblingBackend>	scrobblingBackend;
+            std::optional<FeedbackBackend>	    feedbackBackend;
+            Range							    range;
 
-            FindParameters& setScrobbler(Scrobbler _scrobbler) { scrobbler = _scrobbler; return *this; }
+            FindParameters& setFeedbackBackend(FeedbackBackend _feedbackBackend) { feedbackBackend = _feedbackBackend; return *this; }
+            FindParameters& setScrobblingBackend(ScrobblingBackend _scrobblingBackend) { scrobblingBackend = _scrobblingBackend; return *this; }
             FindParameters& setRange(Range _range) { range = _range; return *this; }
         };
 
-        static inline const std::size_t             MinNameLength{ 3 };
-        static inline const std::size_t             MaxNameLength{ 15 };
-        static inline const AudioFormat             defaultSubsonicTranscodeFormat{ AudioFormat::OGG_OPUS };
-        static inline const Bitrate                 defaultSubsonicTranscodeBitrate{ 128000 };
-        static inline const UITheme                 defaultUITheme{ UITheme::Dark };
-        static inline const SubsonicArtistListMode  defaultSubsonicArtistListMode{ SubsonicArtistListMode::AllArtists };
-        static inline const Scrobbler               defaultScrobbler{ Scrobbler::Internal };
+        static inline constexpr std::size_t             MinNameLength{ 3 };
+        static inline constexpr std::size_t             MaxNameLength{ 15 };
+        static inline constexpr AudioFormat             defaultSubsonicTranscodeFormat{ AudioFormat::OGG_OPUS };
+        static inline constexpr Bitrate                 defaultSubsonicTranscodeBitrate{ 128000 };
+        static inline constexpr UITheme                 defaultUITheme{ UITheme::Dark };
+        static inline constexpr SubsonicArtistListMode  defaultSubsonicArtistListMode{ SubsonicArtistListMode::AllArtists };
+        static inline constexpr ScrobblingBackend       defaultScrobblingBackend{ ScrobblingBackend::Internal };
+        static inline constexpr FeedbackBackend         defaultFeedbackBackend{ FeedbackBackend::Internal };
 
         User() = default;
 
@@ -88,7 +91,8 @@ namespace Database {
         void setUITheme(UITheme uiTheme) { _uiTheme = uiTheme; }
         void clearAuthTokens();
         void setSubsonicArtistListMode(SubsonicArtistListMode mode) { _subsonicArtistListMode = mode; }
-        void setScrobbler(Scrobbler scrobbler) { _scrobbler = scrobbler; }
+        void setFeedbackBackend(FeedbackBackend feedbackBackend) { _feedbackBackend = feedbackBackend; }
+        void setScrobblingBackend(ScrobblingBackend scrobblingBackend) { _scrobblingBackend = scrobblingBackend; }
         void setListenBrainzToken(const std::optional<UUID>& MBID) { _listenbrainzToken = MBID ? MBID->getAsString() : ""; }
 
         // read
@@ -102,7 +106,8 @@ namespace Database {
         bool                    isRadioSet() const { return _radio; }
         UITheme                 getUITheme() const { return _uiTheme; }
         SubsonicArtistListMode  getSubsonicArtistListMode() const { return _subsonicArtistListMode; }
-        Scrobbler               getScrobbler() const { return _scrobbler; }
+        FeedbackBackend         getFeedbackBackend() const { return _feedbackBackend; }
+        ScrobblingBackend       getScrobblingBackend() const { return _scrobblingBackend; }
         std::optional<UUID>     getListenBrainzToken() const { return UUID::fromString(_listenbrainzToken); }
 
         template<class Action>
@@ -117,7 +122,8 @@ namespace Database {
             Wt::Dbo::field(a, _subsonicDefaultTranscodeBitrate, "subsonic_default_transcode_bitrate");
             Wt::Dbo::field(a, _subsonicArtistListMode, "subsonic_artist_list_mode");
             Wt::Dbo::field(a, _uiTheme, "ui_theme");
-            Wt::Dbo::field(a, _scrobbler, "scrobbler");
+            Wt::Dbo::field(a, _feedbackBackend, "feedback_backend");
+            Wt::Dbo::field(a, _scrobblingBackend, "scrobbling_backend");
             Wt::Dbo::field(a, _listenbrainzToken, "listenbrainz_token");
 
             // UI player settings
@@ -138,7 +144,8 @@ namespace Database {
         std::string     _passwordHash;
         Wt::WDateTime   _lastLogin;
         UITheme         _uiTheme{ defaultUITheme };
-        Scrobbler       _scrobbler{ defaultScrobbler };
+        FeedbackBackend _feedbackBackend{ defaultFeedbackBackend };
+        ScrobblingBackend _scrobblingBackend{ defaultScrobblingBackend };
         std::string     _listenbrainzToken; // Musicbrainz Identifier
 
         // Admin defined settings
diff --git a/src/libs/services/database/test/Artist.cpp b/src/libs/services/database/test/Artist.cpp
index fe849cf9..6e9020fd 100644
--- a/src/libs/services/database/test/Artist.cpp
+++ b/src/libs/services/database/test/Artist.cpp
@@ -23,415 +23,423 @@ using namespace Database;
 
 TEST_F(DatabaseFixture, Artist)
 {
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_FALSE(Artist::exists(session, 35));
-		EXPECT_FALSE(Artist::exists(session, 0));
-		EXPECT_FALSE(Artist::exists(session, 1));
-		EXPECT_EQ(Artist::getCount(session), 0);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_FALSE(Artist::exists(session, 35));
+        EXPECT_FALSE(Artist::exists(session, 0));
+        EXPECT_FALSE(Artist::exists(session, 1));
+        EXPECT_EQ(Artist::getCount(session), 0);
+    }
 
-	ScopedArtist artist {session, "MyArtist"};
+    ScopedArtist artist{ session, "MyArtist" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		EXPECT_TRUE(artist.get());
-		EXPECT_FALSE(!artist.get());
-		EXPECT_EQ(artist.get()->getId(), artist.getId());
+        EXPECT_TRUE(artist.get());
+        EXPECT_FALSE(!artist.get());
+        EXPECT_EQ(artist.get()->getId(), artist.getId());
 
-		EXPECT_TRUE(Artist::exists(session, artist.getId()));
-		EXPECT_EQ(Artist::getCount(session), 1);
-	}
+        EXPECT_TRUE(Artist::exists(session, artist.getId()));
+        EXPECT_EQ(Artist::getCount(session), 1);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto artists {Artist::find(session, Artist::FindParameters {})};
-		ASSERT_EQ(artists.results.size(), 1);
-		EXPECT_EQ(artists.results.front(), artist.getId());
+        auto artists{ Artist::findIds(session, Artist::FindParameters {}) };
+        ASSERT_EQ(artists.results.size(), 1);
+        EXPECT_EQ(artists.results.front(), artist.getId());
 
-		artists = Artist::findAllOrphans(session, Range {});
-		ASSERT_EQ(artists.results.size(), 1);
-		EXPECT_EQ(artists.results.front(), artist.getId());
-	}
+        artists = Artist::findOrphanIds(session, Range{});
+        ASSERT_EQ(artists.results.size(), 1);
+        EXPECT_EQ(artists.results.front(), artist.getId());
+    }
+
+    
+    {
+        auto transaction{ session.createSharedTransaction() };
+
+        auto artists{ Artist::find(session, Artist::FindParameters {}) };
+        ASSERT_EQ(artists.results.size(), 1);
+        EXPECT_EQ(artists.results.front()->getId(), artist.getId());
+    }
 }
 
 TEST_F(DatabaseFixture, Artist_singleTrack)
 {
-	ScopedTrack track {session, "MyTrack"};
-	ScopedArtist artist {session, "MyArtist"};
+    ScopedTrack track{ session, "MyTrack" };
+    ScopedArtist artist{ session, "MyArtist" };
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		track.get().modify()->setName("MyTrackName");
-		TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
-	}
+        track.get().modify()->setName("MyTrackName");
+        TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto artists {track->getArtists({TrackArtistLinkType::Artist})};
-		ASSERT_EQ(artists.size(), 1);
-		EXPECT_EQ(artists.front()->getId(), artist.getId());
+        auto artists{ track->getArtists({TrackArtistLinkType::Artist}) };
+        ASSERT_EQ(artists.size(), 1);
+        EXPECT_EQ(artists.front()->getId(), artist.getId());
 
-		ASSERT_EQ(track->getArtistLinks().size(), 1);
-		auto artistLink {track->getArtistLinks().front()};
-		EXPECT_EQ(artistLink->getTrack()->getId(), track.getId());
-		EXPECT_EQ(artistLink->getArtist()->getId(), artist.getId());
+        ASSERT_EQ(track->getArtistLinks().size(), 1);
+        auto artistLink{ track->getArtistLinks().front() };
+        EXPECT_EQ(artistLink->getTrack()->getId(), track.getId());
+        EXPECT_EQ(artistLink->getArtist()->getId(), artist.getId());
 
-		ASSERT_EQ(track->getArtists({TrackArtistLinkType::Artist}).size(), 1);
-		EXPECT_TRUE(track->getArtists({TrackArtistLinkType::ReleaseArtist}).empty());
-		EXPECT_EQ(track->getArtists({}).size(), 1);
-	}
+        ASSERT_EQ(track->getArtists({ TrackArtistLinkType::Artist }).size(), 1);
+        EXPECT_TRUE(track->getArtists({ TrackArtistLinkType::ReleaseArtist }).empty());
+        EXPECT_EQ(track->getArtists({}).size(), 1);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto artists {track->getArtistIds({TrackArtistLinkType::Artist})};
-		ASSERT_EQ(artists.size(), 1);
-		EXPECT_EQ(artists.front(), artist.getId());
+        auto artists{ track->getArtistIds({TrackArtistLinkType::Artist}) };
+        ASSERT_EQ(artists.size(), 1);
+        EXPECT_EQ(artists.front(), artist.getId());
 
-		ASSERT_EQ(track->getArtistIds({TrackArtistLinkType::Artist}).size(), 1);
-		EXPECT_TRUE(track->getArtistIds({TrackArtistLinkType::ReleaseArtist}).empty());
-		EXPECT_EQ(track->getArtistIds({}).size(), 1);
-	}
+        ASSERT_EQ(track->getArtistIds({ TrackArtistLinkType::Artist }).size(), 1);
+        EXPECT_TRUE(track->getArtistIds({ TrackArtistLinkType::ReleaseArtist }).empty());
+        EXPECT_EQ(track->getArtistIds({}).size(), 1);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		auto tracks {Track::find(session, Track::FindParameters{}.setName("MyTrackName").setArtistName("MyArtist"))};
-		ASSERT_EQ(tracks.results.size(), 1);
-		EXPECT_EQ(tracks.results.front(), track.getId());
-	}
-	{
-		auto transaction {session.createSharedTransaction()};
-		auto tracks {Track::find(session, Track::FindParameters{}.setName("MyTrackName").setArtistName("MyArtistFoo"))};
-		EXPECT_EQ(tracks.results.size(), 0);
-	}
-	{
-		auto transaction {session.createSharedTransaction()};
-		auto tracks {Track::find(session, Track::FindParameters{}.setName("MyTrackNameFoo").setArtistName("MyArtist"))};
-		EXPECT_EQ(tracks.results.size(), 0);
-	}
-	{
-		auto transaction {session.createSharedTransaction()};
-		auto artists {Artist::find(session, Artist::FindParameters{}.setTrack(track->getId()))};
-		ASSERT_EQ(artists.results.size(), 1);
-		EXPECT_EQ(artists.results.front(), artist.getId());
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackName").setArtistName("MyArtist")) };
+        ASSERT_EQ(tracks.results.size(), 1);
+        EXPECT_EQ(tracks.results.front(), track.getId());
+    }
+    {
+        auto transaction{ session.createSharedTransaction() };
+        auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackName").setArtistName("MyArtistFoo")) };
+        EXPECT_EQ(tracks.results.size(), 0);
+    }
+    {
+        auto transaction{ session.createSharedTransaction() };
+        auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackNameFoo").setArtistName("MyArtist")) };
+        EXPECT_EQ(tracks.results.size(), 0);
+    }
+    {
+        auto transaction{ session.createSharedTransaction() };
+        auto artists{ Artist::findIds(session, Artist::FindParameters{}.setTrack(track->getId())) };
+        ASSERT_EQ(artists.results.size(), 1);
+        EXPECT_EQ(artists.results.front(), artist.getId());
+    }
 }
 
 TEST_F(DatabaseFixture, Artist_singleTracktMultiRoles)
 {
-	ScopedTrack track {session, "MyTrack"};
-	ScopedArtist artist {session, "MyArtist"};
-	{
-		auto transaction {session.createUniqueTransaction()};
+    ScopedTrack track{ session, "MyTrack" };
+    ScopedArtist artist{ session, "MyArtist" };
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
-		TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::ReleaseArtist);
-		TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Writer);
-	}
+        TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
+        TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::ReleaseArtist);
+        TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Writer);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_EQ(Artist::find(session, Artist::FindParameters {}).results.size(), 1);
-		EXPECT_EQ(Artist::find(session, Artist::FindParameters {}.setLinkType(TrackArtistLinkType::Artist)).results.size(), 1);
-		EXPECT_EQ(Artist::find(session, Artist::FindParameters {}.setLinkType(TrackArtistLinkType::ReleaseArtist)).results.size(), 1);
-		EXPECT_EQ(Artist::find(session, Artist::FindParameters {}.setLinkType(TrackArtistLinkType::Writer)).results.size(), 1);
-		EXPECT_EQ(Artist::find(session, Artist::FindParameters {}.setLinkType(TrackArtistLinkType::Composer)).results.size(), 0);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}).results.size(), 1);
+        EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::Artist)).results.size(), 1);
+        EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::ReleaseArtist)).results.size(), 1);
+        EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::Writer)).results.size(), 1);
+        EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::Composer)).results.size(), 0);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto artists {track->getArtists({TrackArtistLinkType::Artist})};
-		ASSERT_EQ(artists.size(), 1);
-		EXPECT_EQ(artists.front()->getId(), artist.getId());
+        auto artists{ track->getArtists({TrackArtistLinkType::Artist}) };
+        ASSERT_EQ(artists.size(), 1);
+        EXPECT_EQ(artists.front()->getId(), artist.getId());
 
-		artists = track->getArtists({TrackArtistLinkType::ReleaseArtist});
-		ASSERT_EQ(artists.size(), 1);
-		EXPECT_EQ(artists.front()->getId(), artist.getId());
+        artists = track->getArtists({ TrackArtistLinkType::ReleaseArtist });
+        ASSERT_EQ(artists.size(), 1);
+        EXPECT_EQ(artists.front()->getId(), artist.getId());
 
-		EXPECT_EQ(track->getArtistLinks().size(), 3);
+        EXPECT_EQ(track->getArtistLinks().size(), 3);
 
-		auto tracks {Track::find(session, Track::FindParameters {}.setArtist(artist.getId()))};
-		EXPECT_EQ(tracks.results.size(), 1);
+        auto tracks{ Track::findIds(session, Track::FindParameters {}.setArtist(artist.getId())) };
+        EXPECT_EQ(tracks.results.size(), 1);
 
-		tracks = Track::find(session, Track::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::ReleaseArtist}));
-		EXPECT_EQ(tracks.results.size(), 1);
-		tracks = Track::find(session, Track::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Artist}));
-		EXPECT_EQ(tracks.results.size(), 1);
-		tracks = Track::find(session, Track::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Writer}));
-		EXPECT_EQ(tracks.results.size(), 1);
+        tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::ReleaseArtist }));
+        EXPECT_EQ(tracks.results.size(), 1);
+        tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Artist }));
+        EXPECT_EQ(tracks.results.size(), 1);
+        tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Writer }));
+        EXPECT_EQ(tracks.results.size(), 1);
 
-		tracks = Track::find(session, Track::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Composer}));
-		EXPECT_EQ(tracks.results.size(), 0);
-	}
+        tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Composer }));
+        EXPECT_EQ(tracks.results.size(), 0);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		EnumSet<TrackArtistLinkType> types{ TrackArtistLink::findUsedTypes(session, artist.getId()) };
-		EXPECT_TRUE(types.contains(TrackArtistLinkType::ReleaseArtist));
-		EXPECT_TRUE(types.contains(TrackArtistLinkType::Artist));
-		EXPECT_TRUE(types.contains(TrackArtistLinkType::Writer));
-		EXPECT_FALSE(types.contains(TrackArtistLinkType::Composer));
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EnumSet<TrackArtistLinkType> types{ TrackArtistLink::findUsedTypes(session, artist.getId()) };
+        EXPECT_TRUE(types.contains(TrackArtistLinkType::ReleaseArtist));
+        EXPECT_TRUE(types.contains(TrackArtistLinkType::Artist));
+        EXPECT_TRUE(types.contains(TrackArtistLinkType::Writer));
+        EXPECT_FALSE(types.contains(TrackArtistLinkType::Composer));
+    }
 }
 
 TEST_F(DatabaseFixture, Artist_singleTrackMultiArtists)
 {
-	ScopedTrack track {session, "track"};
-	ScopedArtist artist1 {session, "artist1"};
-	ScopedArtist artist2 {session, "artist2"};
-	ASSERT_NE(artist1.getId(), artist2.getId());
+    ScopedTrack track{ session, "track" };
+    ScopedArtist artist1{ session, "artist1" };
+    ScopedArtist artist2{ session, "artist2" };
+    ASSERT_NE(artist1.getId(), artist2.getId());
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		TrackArtistLink::create(session, track.get(), artist1.get(), TrackArtistLinkType::Artist);
-		TrackArtistLink::create(session, track.get(), artist2.get(), TrackArtistLinkType::Artist);
-	}
+        TrackArtistLink::create(session, track.get(), artist1.get(), TrackArtistLinkType::Artist);
+        TrackArtistLink::create(session, track.get(), artist2.get(), TrackArtistLinkType::Artist);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto artists {track->getArtists({TrackArtistLinkType::Artist})};
-		ASSERT_EQ(artists.size(), 2);
-		EXPECT_TRUE((artists[0]->getId() == artist1.getId() && artists[1]->getId() == artist2.getId())
-			|| (artists[0]->getId() == artist2.getId() && artists[1]->getId() == artist1.getId()));
+        auto artists{ track->getArtists({TrackArtistLinkType::Artist}) };
+        ASSERT_EQ(artists.size(), 2);
+        EXPECT_TRUE((artists[0]->getId() == artist1.getId() && artists[1]->getId() == artist2.getId())
+            || (artists[0]->getId() == artist2.getId() && artists[1]->getId() == artist1.getId()));
 
-		EXPECT_EQ(track->getArtists({}).size(), 2);
-		EXPECT_EQ(track->getArtists({TrackArtistLinkType::Artist}).size(), 2);
-		EXPECT_TRUE(track->getArtists({TrackArtistLinkType::ReleaseArtist}).empty());
-		EXPECT_EQ(Artist::find(session, Artist::FindParameters {}).results.size(), 2);
-		EXPECT_EQ(Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::Random)).results.size(), 2);
-	}
+        EXPECT_EQ(track->getArtists({}).size(), 2);
+        EXPECT_EQ(track->getArtists({ TrackArtistLinkType::Artist }).size(), 2);
+        EXPECT_TRUE(track->getArtists({ TrackArtistLinkType::ReleaseArtist }).empty());
+        EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}).results.size(), 2);
+        EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setSortMethod(ArtistSortMethod::Random)).results.size(), 2);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto tracks {Track::find(session, Track::FindParameters {}.setArtist(artist1->getId()))};
-		ASSERT_EQ(tracks.results.size(), 1);
-		EXPECT_EQ(tracks.results.front(), track->getId());
+        auto tracks{ Track::findIds(session, Track::FindParameters {}.setArtist(artist1->getId())) };
+        ASSERT_EQ(tracks.results.size(), 1);
+        EXPECT_EQ(tracks.results.front(), track->getId());
 
-		tracks = Track::find(session, Track::FindParameters {}.setArtist(artist2->getId()));
-		ASSERT_EQ(tracks.results.size(), 1);
-		EXPECT_EQ(tracks.results.front(), track->getId());
+        tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist2->getId()));
+        ASSERT_EQ(tracks.results.size(), 1);
+        EXPECT_EQ(tracks.results.front(), track->getId());
 
-		tracks = Track::find(session, Track::FindParameters {}.setArtist(artist1->getId(), {TrackArtistLinkType::ReleaseArtist}));
-		EXPECT_EQ(tracks.results.size(), 0);
+        tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist1->getId(), { TrackArtistLinkType::ReleaseArtist }));
+        EXPECT_EQ(tracks.results.size(), 0);
 
-		tracks = Track::find(session, Track::FindParameters {}.setArtist(artist1->getId(), {TrackArtistLinkType::Artist}));
-		EXPECT_EQ(tracks.results.size(), 1);
+        tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist1->getId(), { TrackArtistLinkType::Artist }));
+        EXPECT_EQ(tracks.results.size(), 1);
 
-		tracks = Track::find(session, Track::FindParameters {}.setArtist(artist2->getId(), {TrackArtistLinkType::ReleaseArtist}));
-		EXPECT_EQ(tracks.results.size(), 0);
+        tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist2->getId(), { TrackArtistLinkType::ReleaseArtist }));
+        EXPECT_EQ(tracks.results.size(), 0);
 
-		tracks = Track::find(session, Track::FindParameters {}.setArtist(artist2->getId(), {TrackArtistLinkType::Artist}));
-		EXPECT_EQ(tracks.results.size(), 1);
-	}
+        tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist2->getId(), { TrackArtistLinkType::Artist }));
+        EXPECT_EQ(tracks.results.size(), 1);
+    }
 }
 
 TEST_F(DatabaseFixture, Artist_findByName)
 {
-	ScopedArtist artist {session, "AAA"};
-	ScopedTrack track {session, "MyTrack"}; // filters does not work on orphans
+    ScopedArtist artist{ session, "AAA" };
+    ScopedTrack track{ session, "MyTrack" }; // filters does not work on orphans
 
-	{
-		auto transaction {session.createUniqueTransaction()};
-		artist.get().modify()->setSortName("ZZZ");
-		TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
-	}
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        artist.get().modify()->setSortName("ZZZ");
+        TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		EXPECT_TRUE(Artist::find(session, Artist::FindParameters {}.setKeywords({"N"})).results.empty());
+        EXPECT_TRUE(Artist::findIds(session, Artist::FindParameters{}.setKeywords({ "N" })).results.empty());
 
-		const auto artistsByAAA {Artist::find(session, Artist::FindParameters {}.setKeywords({"A"}))};
-		ASSERT_EQ(artistsByAAA.results.size(), 1);
-		EXPECT_EQ(artistsByAAA.results.front(), artist.getId());
+        const auto artistsByAAA{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"A"})) };
+        ASSERT_EQ(artistsByAAA.results.size(), 1);
+        EXPECT_EQ(artistsByAAA.results.front(), artist.getId());
 
-		const auto artistsByZZZ {Artist::Artist::find(session, Artist::FindParameters {}.setKeywords({"Z"}))};
-		ASSERT_EQ(artistsByZZZ.results.size(), 1);
-		EXPECT_EQ(artistsByZZZ.results.front(), artist.getId());
+        const auto artistsByZZZ{ Artist::Artist::findIds(session, Artist::FindParameters {}.setKeywords({"Z"})) };
+        ASSERT_EQ(artistsByZZZ.results.size(), 1);
+        EXPECT_EQ(artistsByZZZ.results.front(), artist.getId());
 
-		EXPECT_TRUE(Artist::find(session, "NNN").empty());
-		EXPECT_EQ(Artist::find(session, "AAA").size(), 1);
-	}
+        EXPECT_TRUE(Artist::find(session, "NNN").empty());
+        EXPECT_EQ(Artist::find(session, "AAA").size(), 1);
+    }
 }
 
 TEST_F(DatabaseFixture, Artist_findByNameEscaped)
 {
-	ScopedArtist artist1 {session, "MyArtist%"};
-	ScopedArtist artist2 {session, "%MyArtist"};
-	ScopedArtist artist3 {session, "%_MyArtist"};
+    ScopedArtist artist1{ session, R"(MyArtist%)" };
+    ScopedArtist artist2{ session, R"(%MyArtist)" };
+    ScopedArtist artist3{ session, R"(%_MyArtist)" };
 
-	ScopedArtist artist4 {session, "MyArtist%foo"};
-	ScopedArtist artist5 {session, "foo%MyArtist"};
-	ScopedArtist artist6 {session, "%AMyArtist"};
+    ScopedArtist artist4{ session, R"(MyArtist%foo)" };
+    ScopedArtist artist5{ session, R"(foo%MyArtist)" };
+    ScopedArtist artist6{ session, R"(%AMyArtist)" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		{
-			const auto artists {Artist::find(session, "MyArtist%")};
-			ASSERT_TRUE(artists.size() == 1);
-			EXPECT_EQ(artists.front()->getId(), artist1.getId());
-			EXPECT_TRUE(Artist::find(session, "MyArtistFoo").empty());
-		}
-		{
-			const auto artists {Artist::find(session, "%MyArtist")};
-			ASSERT_TRUE(artists.size() == 1);
-			EXPECT_EQ(artists.front()->getId(), artist2.getId());
-			EXPECT_TRUE(Artist::find(session, "FooMyArtist").empty());
-		}
-		{
-			const auto artists {Artist::find(session, "%_MyArtist")};
-			ASSERT_TRUE(artists.size() == 1);
-			ASSERT_EQ(artists.front()->getId(), artist3.getId());
-			EXPECT_TRUE(Artist::find(session, "%CMyArtist").empty());
-		}
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        {
+            const auto artists{ Artist::find(session, R"(MyArtist%)") };
+            ASSERT_TRUE(artists.size() == 1);
+            EXPECT_EQ(artists.front()->getId(), artist1.getId());
+            EXPECT_TRUE(Artist::find(session, R"(MyArtistFoo)").empty());
+        }
+        {
+            const auto artists{ Artist::find(session, R"(%MyArtist)") };
+            ASSERT_TRUE(artists.size() == 1);
+            EXPECT_EQ(artists.front()->getId(), artist2.getId());
+            EXPECT_TRUE(Artist::find(session, R"(FooMyArtist)").empty());
+        }
+        {
+            const auto artists{ Artist::find(session, R"(%_MyArtist)") };
+            ASSERT_TRUE(artists.size() == 1);
+            ASSERT_EQ(artists.front()->getId(), artist3.getId());
+            EXPECT_TRUE(Artist::find(session, R"(%CMyArtist)").empty());
+        }
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		{
-			const auto artists {Artist::find(session, Artist::FindParameters {}.setKeywords({"MyArtist"}))};
-			EXPECT_EQ(artists.results.size(), 6);
-		}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        {
+            const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"MyArtist"})) };
+            EXPECT_EQ(artists.results.size(), 6);
+        }
 
-		{
-			const auto artists {Artist::find(session, Artist::FindParameters {}.setKeywords({"MyArtist%"}).setSortMethod(ArtistSortMethod::ByName))};
-			ASSERT_EQ(artists.results.size(), 2);
-			EXPECT_EQ(artists.results[0], artist1.getId());
-			EXPECT_EQ(artists.results[1], artist4.getId());
-		}
+        {
+            const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"MyArtist%"}).setSortMethod(ArtistSortMethod::ByName)) };
+            ASSERT_EQ(artists.results.size(), 2);
+            EXPECT_EQ(artists.results[0], artist1.getId());
+            EXPECT_EQ(artists.results[1], artist4.getId());
+        }
 
-		{
-			const auto artists {Artist::find(session, Artist::FindParameters {}.setKeywords({"%MyArtist"}).setSortMethod(ArtistSortMethod::ByName))};
-			ASSERT_EQ(artists.results.size(), 2);
-			EXPECT_EQ(artists.results[0], artist2.getId());
-			EXPECT_EQ(artists.results[1], artist5.getId());
-		}
+        {
+            const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"%MyArtist"}).setSortMethod(ArtistSortMethod::ByName)) };
+            ASSERT_EQ(artists.results.size(), 2);
+            EXPECT_EQ(artists.results[0], artist2.getId());
+            EXPECT_EQ(artists.results[1], artist5.getId());
+        }
 
-		{
-			const auto artists {Artist::find(session, Artist::FindParameters {}.setKeywords({"_MyArtist"}).setSortMethod(ArtistSortMethod::ByName))};
-			ASSERT_EQ(artists.results.size(), 1);
-			EXPECT_EQ(artists.results[0], artist3.getId());
-		}
-	}
+        {
+            const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"_MyArtist"}).setSortMethod(ArtistSortMethod::ByName)) };
+            ASSERT_EQ(artists.results.size(), 1);
+            EXPECT_EQ(artists.results[0], artist3.getId());
+        }
+    }
 }
 
 TEST_F(DatabaseFixture, Artist_sortMethod)
 {
-	ScopedArtist artistA {session, "artistA"};
-	ScopedArtist artistB {session, "artistB"};
+    ScopedArtist artistA{ session, "artistA" };
+    ScopedArtist artistB{ session, "artistB" };
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		artistA.get().modify()->setSortName("sortNameB");
-		artistB.get().modify()->setSortName("sortNameA");
-	}
+        artistA.get().modify()->setSortName("sortNameB");
+        artistB.get().modify()->setSortName("sortNameA");
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto allArtistsByName {Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::ByName))};
-		auto allArtistsBySortName {Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::BySortName))};
+        auto allArtistsByName{ Artist::findIds(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::ByName)) };
+        auto allArtistsBySortName{ Artist::findIds(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::BySortName)) };
 
-		ASSERT_EQ(allArtistsByName.results.size(), 2);
-		EXPECT_EQ(allArtistsByName.results.front(), artistA.getId());
-		EXPECT_EQ(allArtistsByName.results.back(), artistB.getId());
+        ASSERT_EQ(allArtistsByName.results.size(), 2);
+        EXPECT_EQ(allArtistsByName.results.front(), artistA.getId());
+        EXPECT_EQ(allArtistsByName.results.back(), artistB.getId());
 
-		ASSERT_EQ(allArtistsBySortName.results.size(), 2);
-		EXPECT_EQ(allArtistsBySortName.results.front(), artistB.getId());
-		EXPECT_EQ(allArtistsBySortName.results.back(), artistA.getId());
-	}
+        ASSERT_EQ(allArtistsBySortName.results.size(), 2);
+        EXPECT_EQ(allArtistsBySortName.results.front(), artistB.getId());
+        EXPECT_EQ(allArtistsBySortName.results.back(), artistA.getId());
+    }
 }
 
 TEST_F(DatabaseFixture, Artist_nonReleaseTracks)
 {
-	ScopedArtist artist {session, "artist"};
-	ScopedTrack track1 {session, "MyTrack1"};
-	ScopedTrack track2 {session, "MyTrack2"};
-	ScopedRelease release{session, "MyRelease"};
+    ScopedArtist artist{ session, "artist" };
+    ScopedTrack track1{ session, "MyTrack1" };
+    ScopedTrack track2{ session, "MyTrack2" };
+    ScopedRelease release{ session, "MyRelease" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto tracks {Track::find(session, Track::FindParameters {}.setNonRelease(true).setArtist(artist->getId()))};
-		EXPECT_EQ(tracks.results.size(), 0);
-	}
+        auto tracks{ Track::findIds(session, Track::FindParameters {}.setNonRelease(true).setArtist(artist->getId())) };
+        EXPECT_EQ(tracks.results.size(), 0);
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		TrackArtistLink::create(session, track1.get(), artist.get(), TrackArtistLinkType::Artist);
-		TrackArtistLink::create(session, track2.get(), artist.get(), TrackArtistLinkType::Artist);
+        TrackArtistLink::create(session, track1.get(), artist.get(), TrackArtistLinkType::Artist);
+        TrackArtistLink::create(session, track2.get(), artist.get(), TrackArtistLinkType::Artist);
 
-		track1.get().modify()->setRelease(release.get());
-	}
+        track1.get().modify()->setRelease(release.get());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		const auto tracks {Track::find(session, Track::FindParameters {}.setArtist(artist.getId()).setNonRelease(true))};
-		ASSERT_EQ(tracks.results.size(), 1);
-		EXPECT_EQ(tracks.results.front(), track2.getId());
-	}
+        const auto tracks{ Track::findIds(session, Track::FindParameters {}.setArtist(artist.getId()).setNonRelease(true)) };
+        ASSERT_EQ(tracks.results.size(), 1);
+        EXPECT_EQ(tracks.results.front(), track2.getId());
+    }
 }
 
 TEST_F(DatabaseFixture, Artist_findByRelease)
 {
-	ScopedArtist artist {session, "artist"};
-	ScopedTrack track {session, "MyTrack"};
-	ScopedRelease release{session, "MyRelease"};
+    ScopedArtist artist{ session, "artist" };
+    ScopedTrack track{ session, "MyTrack" };
+    ScopedRelease release{ session, "MyRelease" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		const auto artists {Artist::find(session, Artist::FindParameters {}.setRelease(release.getId()))};
-		EXPECT_EQ(artists.results.size(), 0);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setRelease(release.getId())) };
+        EXPECT_EQ(artists.results.size(), 0);
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
-		TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
-	}
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		const auto artists {Artist::find(session, Artist::FindParameters {}.setRelease(release.getId()))};
-		EXPECT_EQ(artists.results.size(), 0);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setRelease(release.getId())) };
+        EXPECT_EQ(artists.results.size(), 0);
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
-		track.get().modify()->setRelease(release.get());
-	}
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        track.get().modify()->setRelease(release.get());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		const auto artists {Artist::find(session, Artist::FindParameters {}.setRelease(release.getId()))};
-		ASSERT_EQ(artists.results.size(), 1);
-		EXPECT_EQ(artists.results.front(), artist.getId());
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setRelease(release.getId())) };
+        ASSERT_EQ(artists.results.size(), 1);
+        EXPECT_EQ(artists.results.front(), artist.getId());
+    }
 }
-
diff --git a/src/libs/services/database/test/Cluster.cpp b/src/libs/services/database/test/Cluster.cpp
index 0b045fd5..8e0186b6 100644
--- a/src/libs/services/database/test/Cluster.cpp
+++ b/src/libs/services/database/test/Cluster.cpp
@@ -133,11 +133,11 @@ TEST_F(DatabaseFixture, Cluster_singleTrack)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Track::find(session, Track::FindParameters {}.setClusters({cluster1.getId()})) };
+        auto tracks{ Track::findIds(session, Track::FindParameters {}.setClusters({cluster1.getId()})) };
         ASSERT_EQ(tracks.results.size(), 1);
         EXPECT_EQ(tracks.results.front(), track.getId());
 
-        tracks = Track::find(session, Track::FindParameters{}.setClusters({ cluster2.getId() }));
+        tracks = Track::findIds(session, Track::FindParameters{}.setClusters({ cluster2.getId() }));
         EXPECT_TRUE(tracks.results.empty());
     }
 
@@ -154,6 +154,51 @@ TEST_F(DatabaseFixture, Cluster_singleTrack)
     }
 }
 
+TEST_F(DatabaseFixture, Cluster_singleTrackWithSeveralClusters)
+{
+    ScopedTrack track{ session, "MyTrack" };
+    ScopedClusterType clusterType{ session, "MyClusterType" };
+
+    ScopedCluster cluster1{ session, clusterType.lockAndGet(), "MyCluster1" };
+    ScopedCluster cluster2{ session, clusterType.lockAndGet(), "MyCluster2" };
+
+    const std::vector<ClusterId> clusterIds{ cluster1.getId(), cluster2.getId() };
+
+    {
+        auto transaction{ session.createSharedTransaction() };
+
+        const auto tracks{ Track::findIds(session, Track::FindParameters{}.setClusters(clusterIds)) };
+        EXPECT_TRUE(tracks.results.empty());
+    }
+
+    {
+        auto transaction{ session.createUniqueTransaction() };
+
+        cluster1.get().modify()->addTrack(track.get());
+    }
+
+    {
+        auto transaction{ session.createSharedTransaction() };
+
+        const auto tracks{ Track::findIds(session, Track::FindParameters{}.setClusters(clusterIds)) };
+        EXPECT_TRUE(tracks.results.empty());
+    }
+
+    {
+        auto transaction{ session.createUniqueTransaction() };
+
+        cluster2.get().modify()->addTrack(track.get());
+    }
+
+    {
+        auto transaction{ session.createSharedTransaction() };
+
+        const auto tracks{ Track::findIds(session, Track::FindParameters{}.setClusters(clusterIds)) };
+        ASSERT_FALSE(tracks.results.empty());
+        EXPECT_EQ(tracks.results.front(), track.getId());
+    }
+}
+
 TEST_F(DatabaseFixture, Cluster_multiTracks)
 {
     std::list<ScopedTrack> tracks;
@@ -329,7 +374,7 @@ TEST_F(DatabaseFixture, Cluster_singleTrackSingleReleaseSingleCluster)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Release::find(session, Release::FindParameters {}.setClusters({cluster.getId()})) };
+        const auto releases{ Release::findIds(session, Release::FindParameters {}.setClusters({cluster.getId()})) };
         ASSERT_EQ(releases.results.size(), 1);
         EXPECT_EQ(releases.results.front(), release.getId());
     }
@@ -337,7 +382,7 @@ TEST_F(DatabaseFixture, Cluster_singleTrackSingleReleaseSingleCluster)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Release::find(session, Release::FindParameters {}.setClusters({unusedCluster.getId()})) };
+        const auto releases{ Release::findIds(session, Release::FindParameters {}.setClusters({unusedCluster.getId()})) };
         EXPECT_EQ(releases.results.size(), 0);
     }
 
@@ -370,8 +415,8 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiClusters)
         auto transaction{ session.createSharedTransaction() };
         EXPECT_TRUE(ClusterType::findOrphans(session, Range{}).results.empty());
         EXPECT_EQ(Cluster::findOrphans(session, Range{}).results.size(), 2);
-        EXPECT_TRUE(Release::findOrphans(session, Range{}).results.empty());
-        EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty());
+        EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
+        EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
     }
 
     {
@@ -383,12 +428,12 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiClusters)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Artist::find(session, Artist::FindParameters {}.setClusters({cluster1.getId()})) };
+        auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters({cluster1.getId()})) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results.front(), artist.getId());
 
-        EXPECT_TRUE(Artist::find(session, Artist::FindParameters{}.setClusters({ cluster2.getId() })).results.empty());
-        EXPECT_TRUE(Artist::find(session, Artist::FindParameters{}.setClusters({ cluster3.getId() })).results.empty());
+        EXPECT_TRUE(Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster2.getId() })).results.empty());
+        EXPECT_TRUE(Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster3.getId() })).results.empty());
 
         cluster2.get().modify()->addTrack(track.get());
     }
@@ -396,19 +441,19 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiClusters)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Artist::find(session, Artist::FindParameters {}.setClusters({cluster1.getId()})) };
+        auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters({cluster1.getId()})) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results.front(), artist.getId());
 
-        artists = Artist::find(session, Artist::FindParameters{}.setClusters({ cluster2.getId() }));
+        artists = Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster2.getId() }));
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results.front(), artist.getId());
 
-        artists = Artist::find(session, Artist::FindParameters{}.setClusters({ cluster1.getId() }));
+        artists = Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster1.getId() }));
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results.front(), artist.getId());
 
-        EXPECT_TRUE(Artist::find(session, Artist::FindParameters{}.setClusters({ cluster3.getId() })).results.empty());
+        EXPECT_TRUE(Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster3.getId() })).results.empty());
     }
 }
 
@@ -430,14 +475,14 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiRolesMultiClusters)
     {
         auto transaction{ session.createSharedTransaction() };
         EXPECT_TRUE(Cluster::findOrphans(session, Range{}).results.empty());
-        EXPECT_TRUE(Release::findOrphans(session, Range{}).results.empty());
-        EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty());
+        EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
+        EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
     }
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Artist::find(session, Artist::FindParameters {}.setClusters({cluster.getId()})) };
+        auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters({cluster.getId()})) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results.front(), artist.getId());
     }
@@ -470,7 +515,7 @@ TEST_F(DatabaseFixture, MultiTracksSingleArtistMultiClusters)
     {
         auto transaction{ session.createSharedTransaction() };
         EXPECT_TRUE(Cluster::findOrphans(session, Range{}).results.empty());
-        EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty());
+        EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
     }
 
     {
@@ -479,7 +524,7 @@ TEST_F(DatabaseFixture, MultiTracksSingleArtistMultiClusters)
         std::vector<ClusterId> clusterIds;
         std::transform(std::cbegin(clusters), std::cend(clusters), std::back_inserter(clusterIds), [](const ScopedCluster& cluster) { return cluster.getId(); });
 
-        auto artists{ Artist::find(session, Artist::FindParameters {}.setClusters(clusterIds)) };
+        auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters(clusterIds)) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results.front(), artist.getId());
     }
@@ -505,7 +550,7 @@ TEST_F(DatabaseFixture, MultipleTracksSingleClusterSimilarity)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        const auto similarTracks{ Track::findSimilarTracks(session, {tracks.front().getId()}, Range {}) };
+        const auto similarTracks{ Track::findSimilarTrackIds(session, {tracks.front().getId()}, Range {}) };
         EXPECT_EQ(similarTracks.results.size(), tracks.size() - 1);
         for (const TrackId similarTrackId : similarTracks.results)
         {
@@ -546,14 +591,14 @@ TEST_F(DatabaseFixture, MultipleTracksMultipleClustersSimilarity)
         auto transaction{ session.createSharedTransaction() };
 
         {
-            auto similarTracks{ Track::findSimilarTracks(session, {tracks.back().getId()}, Range {0, 4}) };
+            auto similarTracks{ Track::findSimilarTrackIds(session, {tracks.back().getId()}, Range {0, 4}) };
             EXPECT_EQ(similarTracks.results.size(), 4);
             for (const TrackId similarTrackId : similarTracks.results)
                 EXPECT_TRUE(std::find_if(std::next(std::cbegin(tracks), 5), std::next(std::cend(tracks), -1), [&](const auto& track) { return similarTrackId == track.getId(); }) != std::cend(tracks));
         }
 
         {
-            auto similarTracks{ Track::findSimilarTracks(session, {tracks.front().getId()}, Range {}) };
+            auto similarTracks{ Track::findSimilarTrackIds(session, {tracks.front().getId()}, Range {}) };
             EXPECT_EQ(similarTracks.results.size(), tracks.size() - 1);
             for (const TrackId similarTrackId : similarTracks.results)
                 EXPECT_TRUE(std::find_if(std::next(std::cbegin(tracks), 1), std::cend(tracks), [&](const auto& track) { return similarTrackId == track.getId(); }) != std::cend(tracks));
@@ -582,22 +627,22 @@ TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtistSingleCluster)
 
         EXPECT_TRUE(Cluster::findOrphans(session, Range{}).results.empty());
         EXPECT_TRUE(ClusterType::findOrphans(session, Range{}).results.empty());
-        EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty());
-        EXPECT_TRUE(Release::findOrphans(session, Range{}).results.empty());
+        EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
+        EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
     }
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Artist::find(session, Artist::FindParameters {}.setClusters({cluster.getId()})) };
+        auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters({cluster.getId()})) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results.front(), artist.getId());
 
-        auto releases{ Release::find(session, Release::FindParameters {}.setArtist(artist.getId())) };
+        auto releases{ Release::findIds(session, Release::FindParameters {}.setArtist(artist.getId())) };
         ASSERT_EQ(releases.results.size(), 1);
         EXPECT_EQ(releases.results.front(), release.getId());
 
-        releases = Release::find(session, Release::FindParameters{}.setArtist(artist.getId()).setClusters({ cluster.getId() }));
+        releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId()).setClusters({ cluster.getId() }));
         ASSERT_EQ(releases.results.size(), 1);
         EXPECT_EQ(releases.results.front(), release.getId());
     }
@@ -624,11 +669,11 @@ TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtistMultiClusters)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Release::find(session, Release::FindParameters {}.setArtist(artist.getId())) };
+        auto releases{ Release::findIds(session, Release::FindParameters {}.setArtist(artist.getId())) };
         ASSERT_EQ(releases.results.size(), 1);
         EXPECT_EQ(releases.results.front(), release.getId());
 
-        releases = Release::find(session, Release::FindParameters{}.setArtist(artist.getId()).setClusters({ cluster1.getId(), cluster2.getId() }));
+        releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId()).setClusters({ cluster1.getId(), cluster2.getId() }));
         ASSERT_EQ(releases.results.size(), 1);
         EXPECT_EQ(releases.results.front(), release.getId());
     }
@@ -982,9 +1027,9 @@ TEST_F(DatabaseFixture, MultipleTracksMultipleArtistsMultiClusters)
 
     {
         auto transaction{ session.createSharedTransaction() };
-        EXPECT_TRUE(artist1->findSimilarArtists().results.empty());
-        EXPECT_TRUE(artist2->findSimilarArtists().results.empty());
-        EXPECT_TRUE(artist3->findSimilarArtists().results.empty());
+        EXPECT_TRUE(artist1->findSimilarArtistIds().results.empty());
+        EXPECT_TRUE(artist2->findSimilarArtistIds().results.empty());
+        EXPECT_TRUE(artist3->findSimilarArtistIds().results.empty());
     }
 
     std::list<ScopedTrack> tracks;
@@ -1016,35 +1061,35 @@ TEST_F(DatabaseFixture, MultipleTracksMultipleArtistsMultiClusters)
         auto transaction{ session.createSharedTransaction() };
 
         {
-            auto artists{ artist1->findSimilarArtists() };
+            auto artists{ artist1->findSimilarArtistIds() };
             ASSERT_EQ(artists.results.size(), 1);
             EXPECT_EQ(artists.results.front(), artist2.getId());
         }
 
         {
-            auto artists{ artist1->findSimilarArtists({TrackArtistLinkType::Artist}) };
+            auto artists{ artist1->findSimilarArtistIds({TrackArtistLinkType::Artist}) };
             ASSERT_EQ(artists.results.size(), 1);
             EXPECT_EQ(artists.results.front(), artist2.getId());
         }
 
         {
-            auto artists{ artist1->findSimilarArtists({TrackArtistLinkType::ReleaseArtist}) };
+            auto artists{ artist1->findSimilarArtistIds({TrackArtistLinkType::ReleaseArtist}) };
             EXPECT_EQ(artists.results.empty(), 1);
         }
 
         {
-            auto artists{ artist1->findSimilarArtists({TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist}) };
+            auto artists{ artist1->findSimilarArtistIds({TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist}) };
             ASSERT_EQ(artists.results.size(), 1);
             EXPECT_EQ(artists.results.front(), artist2.getId());
         }
 
         {
-            auto artists{ artist1->findSimilarArtists({TrackArtistLinkType::Composer}) };
+            auto artists{ artist1->findSimilarArtistIds({TrackArtistLinkType::Composer}) };
             EXPECT_TRUE(artists.results.empty());
         }
 
         {
-            auto artists{ artist2->findSimilarArtists() };
+            auto artists{ artist2->findSimilarArtistIds() };
             ASSERT_EQ(artists.results.size(), 2);
             EXPECT_EQ(artists.results[0], artist1.getId());
             EXPECT_EQ(artists.results[1], artist3.getId());
diff --git a/src/libs/services/database/test/DatabaseTest.cpp b/src/libs/services/database/test/DatabaseTest.cpp
index 8e20b757..2b35929f 100644
--- a/src/libs/services/database/test/DatabaseTest.cpp
+++ b/src/libs/services/database/test/DatabaseTest.cpp
@@ -25,85 +25,85 @@ using namespace Database;
 
 TEST_F(DatabaseFixture, MultiTracksSingleArtistSingleRelease)
 {
-	constexpr std::size_t nbTracks {10};
-	std::list<ScopedTrack> tracks;
-	ScopedArtist artist {session, "MyArtst"};
-	ScopedRelease release {session, "MyRelease"};
+    constexpr std::size_t nbTracks{ 10 };
+    std::list<ScopedTrack> tracks;
+    ScopedArtist artist{ session, "MyArtst" };
+    ScopedRelease release{ session, "MyRelease" };
 
-	for (std::size_t i {}; i < nbTracks; ++i)
-	{
-		tracks.emplace_back(session, "MyTrack" + std::to_string(i));
+    for (std::size_t i{}; i < nbTracks; ++i)
+    {
+        tracks.emplace_back(session, "MyTrack" + std::to_string(i));
 
-		auto transaction {session.createUniqueTransaction()};
+        auto transaction{ session.createUniqueTransaction() };
 
-		TrackArtistLink::create(session, tracks.back().get(), artist.get(), TrackArtistLinkType::Artist);
-		tracks.back().get().modify()->setRelease(release.get());
-	}
+        TrackArtistLink::create(session, tracks.back().get(), artist.get(), TrackArtistLinkType::Artist);
+        tracks.back().get().modify()->setRelease(release.get());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_TRUE(Release::findOrphans(session, Range {}).results.empty());
-		EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
+        EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto releases {Release::find(session, Release::FindParameters {}.setArtist(artist.getId()))};
-		ASSERT_EQ(releases.results.size(), 1);
-		EXPECT_EQ(releases.results.front(), release.getId());
+        auto releases{ Release::findIds(session, Release::FindParameters {}.setArtist(artist.getId())) };
+        ASSERT_EQ(releases.results.size(), 1);
+        EXPECT_EQ(releases.results.front(), release.getId());
 
-		const auto releaseTracks {Track::find(session, Track::FindParameters {}.setRelease(release.getId()))};
-		EXPECT_EQ(releaseTracks.results.size(), nbTracks);
-	}
+        const auto releaseTracks{ Track::find(session, Track::FindParameters {}.setRelease(release.getId())) };
+        EXPECT_EQ(releaseTracks.results.size(), nbTracks);
+    }
 }
 
 TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtist)
 {
-	ScopedTrack track {session, "MyTrack"};
-	ScopedRelease release {session, "MyRelease"};
-	ScopedArtist artist {session, "MyArtist"};
+    ScopedTrack track{ session, "MyTrack" };
+    ScopedRelease release{ session, "MyRelease" };
+    ScopedArtist artist{ session, "MyArtist" };
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		auto trackArtistLink {TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist)};
-		track.get().modify()->setRelease(release.get());
-	}
+        auto trackArtistLink{ TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist) };
+        track.get().modify()->setRelease(release.get());
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		auto releases {Release::find(session, Release::FindParameters {}.setArtist(artist.getId()))};
-		ASSERT_EQ(releases.results.size(), 1);
-		EXPECT_EQ(releases.results.front(), release.getId());
+        auto releases{ Release::findIds(session, Release::FindParameters {}.setArtist(artist.getId())) };
+        ASSERT_EQ(releases.results.size(), 1);
+        EXPECT_EQ(releases.results.front(), release.getId());
 
-		auto artists {release->getArtists()};
-		ASSERT_EQ(artists.size(), 1);
-		ASSERT_EQ(artists.front()->getId(), artist.getId());
-	}
+        auto artists{ release->getArtists() };
+        ASSERT_EQ(artists.size(), 1);
+        ASSERT_EQ(artists.front()->getId(), artist.getId());
+    }
 }
 
 TEST_F(DatabaseFixture, SingleUser)
 {
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_TRUE(User::find(session, User::FindParameters {}).results.empty());
-		EXPECT_EQ(User::getCount(session), 0);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_TRUE(User::find(session, User::FindParameters{}).results.empty());
+        EXPECT_EQ(User::getCount(session), 0);
+    }
 
-	ScopedUser user {session, "MyUser"};
+    ScopedUser user{ session, "MyUser" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		EXPECT_EQ(User::find(session, User::FindParameters {}).results.size(), 1);
-		EXPECT_EQ(User::getCount(session), 1);
-	}
+        EXPECT_EQ(User::find(session, User::FindParameters{}).results.size(), 1);
+        EXPECT_EQ(User::getCount(session), 1);
+    }
 }
 
-int main(int argc, char **argv)
+int main(int argc, char** argv)
 {
-	::testing::InitGoogleTest(&argc, argv);
-	return RUN_ALL_TESTS();
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
 }
diff --git a/src/libs/services/database/test/Listen.cpp b/src/libs/services/database/test/Listen.cpp
index 1a821711..04330574 100644
--- a/src/libs/services/database/test/Listen.cpp
+++ b/src/libs/services/database/test/Listen.cpp
@@ -35,7 +35,7 @@ TEST_F(DatabaseFixture, Listen_getAll)
         EXPECT_EQ(Listen::getCount(session), 0);
     }
 
-    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 1}} };
+    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 1}} };
 
     {
         auto transaction{ session.createSharedTransaction() };
@@ -45,7 +45,7 @@ TEST_F(DatabaseFixture, Listen_getAll)
 
     {
         auto transaction{ session.createUniqueTransaction() };
-        ScopedListen listen2{ session, user.get(), track.get(), Scrobbler::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{13, 0, 1}} };
+        ScopedListen listen2{ session, user.get(), track.get(), ScrobblingBackend::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{13, 0, 1}} };
 
         EXPECT_EQ(Listen::getCount(session), 2);
     }
@@ -61,12 +61,12 @@ TEST_F(DatabaseFixture, Listen_get)
 {
     ScopedTrack track{ session, "MyTrack" };
     ScopedUser user{ session, "MyUser" };
-    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 1}} };
+    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 1}} };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto listens{ Listen::find(session, Listen::FindParameters{}.setUser(user->getId()).setScrobbler(Scrobbler::ListenBrainz)) };
+        auto listens{ Listen::find(session, Listen::FindParameters{}.setUser(user->getId()).setScrobblingBackend(ScrobblingBackend::ListenBrainz)) };
         EXPECT_EQ(listens.results.size(), 0);
     }
 
@@ -74,18 +74,18 @@ TEST_F(DatabaseFixture, Listen_get)
         auto transaction{ session.createSharedTransaction() };
 
         {
-            auto listens{ Listen::find(session, Listen::FindParameters{}.setUser(user->getId()).setScrobbler(Scrobbler::Internal)) };
+            auto listens{ Listen::find(session, Listen::FindParameters{}.setUser(user->getId()).setScrobblingBackend(ScrobblingBackend::Internal)) };
             EXPECT_EQ(listens.moreResults, false);
             ASSERT_EQ(listens.results.size(), 1);
             EXPECT_EQ(listens.results.front(), listen->getId());
         }
 
         {
-            auto listens{ Listen::find(session, Listen::FindParameters{}.setUser(user->getId()).setScrobbler(Scrobbler::Internal).setScrobblingState(ScrobblingState::PendingAdd)) };
+            auto listens{ Listen::find(session, Listen::FindParameters{}.setUser(user->getId()).setScrobblingBackend(ScrobblingBackend::Internal).setSyncState(SyncState::PendingAdd)) };
             EXPECT_EQ(listens.results.size(), 1);
         }
         {
-            auto listens{ Listen::find(session, Listen::FindParameters{}.setUser(user->getId()).setScrobbler(Scrobbler::Internal).setScrobblingState(ScrobblingState::Synchronized)) };
+            auto listens{ Listen::find(session, Listen::FindParameters{}.setUser(user->getId()).setScrobblingBackend(ScrobblingBackend::Internal).setSyncState(SyncState::Synchronized)) };
             EXPECT_EQ(listens.results.size(), 0);
         }
     }
@@ -95,14 +95,14 @@ TEST_F(DatabaseFixture, Listen_get_multi)
 {
     ScopedTrack track{ session, "MyTrack" };
     ScopedUser user{ session, "MyUser" };
-    ScopedListen listen3{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 3}} };
-    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 1}} };
-    ScopedListen listen2{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 2}} };
+    ScopedListen listen3{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 3}} };
+    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 1}} };
+    ScopedListen listen2{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 2}} };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto listens{ Listen::find(session, Listen::FindParameters{}.setUser(user->getId()).setScrobbler(Scrobbler::Internal)) };
+        auto listens{ Listen::find(session, Listen::FindParameters{}.setUser(user->getId()).setScrobblingBackend(ScrobblingBackend::Internal)) };
         ASSERT_EQ(listens.results.size(), 3);
         EXPECT_EQ(listens.results[0], listen1.getId());
         EXPECT_EQ(listens.results[1], listen2.getId());
@@ -118,26 +118,26 @@ TEST_F(DatabaseFixture, Listen_get_byDateTime)
     const Wt::WDateTime dateTime2{ Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 2} };
     ASSERT_GT(dateTime2, dateTime1);
 
-    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime1 };
-    ScopedListen listen2{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime2 };
+    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime1 };
+    ScopedListen listen2{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime2 };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
         {
-            Listen::pointer listen{ Listen::find(session, user.getId(), track.getId(), Scrobbler::Internal, dateTime1) };
+            Listen::pointer listen{ Listen::find(session, user.getId(), track.getId(), ScrobblingBackend::Internal, dateTime1) };
             ASSERT_TRUE(listen);
             EXPECT_EQ(listen->getId(), listen1.getId());
         }
 
         {
-            Listen::pointer listen{ Listen::find(session, user.getId(), track.getId(), Scrobbler::Internal, dateTime2) };
+            Listen::pointer listen{ Listen::find(session, user.getId(), track.getId(), ScrobblingBackend::Internal, dateTime2) };
             ASSERT_TRUE(listen);
             EXPECT_EQ(listen->getId(), listen2.getId());
         }
 
         {
-            Listen::pointer listen{ Listen::find(session, user.getId(), track.getId(), Scrobbler::Internal, dateTime2.addSecs(56)) };
+            Listen::pointer listen{ Listen::find(session, user.getId(), track.getId(), ScrobblingBackend::Internal, dateTime2.addSecs(56)) };
             EXPECT_FALSE(listen);
         }
     }
@@ -148,19 +148,19 @@ TEST_F(DatabaseFixture, Listen_getTopArtists)
     ScopedTrack track1{ session, "MyTrack" };
     ScopedUser user{ session, "MyUser" };
     const Wt::WDateTime dateTime1{ Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1} };
-    ScopedListen listen1{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime1 };
+    ScopedListen listen1{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime1 };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt) };
+        auto artists{ Listen::getTopArtists(session, user->getId(), ScrobblingBackend::Internal, {}, std::nullopt) };
         EXPECT_EQ(artists.results.size(), 0);
         EXPECT_EQ(artists.moreResults, false);
     }
 
     ScopedTrack track2{ session, "MyTrack2" };
     ScopedArtist artist1{ session, "MyArtist1" };
-    ScopedListen listen2{ session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime1.addSecs(1) };
+    ScopedListen listen2{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime1.addSecs(1) };
 
     {
         auto transaction{ session.createUniqueTransaction() };
@@ -171,20 +171,20 @@ TEST_F(DatabaseFixture, Listen_getTopArtists)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt) };
+        auto artists{ Listen::getTopArtists(session, user->getId(), ScrobblingBackend::Internal, {}, std::nullopt) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results[0], artist1->getId());
     }
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getTopArtists(session, user->getId(), Scrobbler::ListenBrainz, {}, std::nullopt) };
+        auto artists{ Listen::getTopArtists(session, user->getId(), ScrobblingBackend::ListenBrainz, {}, std::nullopt) };
         ASSERT_EQ(artists.results.size(), 0);
     }
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, TrackArtistLinkType::Producer) };
+        auto artists{ Listen::getTopArtists(session, user->getId(), ScrobblingBackend::Internal, {}, TrackArtistLinkType::Producer) };
         EXPECT_EQ(artists.results.size(), 0);
     }
     {
@@ -194,7 +194,7 @@ TEST_F(DatabaseFixture, Listen_getTopArtists)
         {
             auto transaction{ session.createSharedTransaction() };
 
-            auto artists{ Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {cluster->getId()}, std::nullopt) };
+            auto artists{ Listen::getTopArtists(session, user->getId(), ScrobblingBackend::Internal, {cluster->getId()}, std::nullopt) };
             EXPECT_EQ(artists.results.size(), 0);
         }
     }
@@ -218,24 +218,24 @@ TEST_F(DatabaseFixture, Listen_getTopArtists_multi)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt) };
+        auto artists{ Listen::getTopArtists(session, user->getId(), ScrobblingBackend::Internal, {}, std::nullopt) };
         EXPECT_EQ(artists.results.size(), 0);
     }
 
-    ScopedListen listen1{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(1) };
+    ScopedListen listen1{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime.addSecs(1) };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt) };
+        auto artists{ Listen::getTopArtists(session, user->getId(), ScrobblingBackend::Internal, {}, std::nullopt) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results[0], artist1->getId());
     }
-    ScopedListen listen2{ session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(2) };
-    ScopedListen listen3{ session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(3) };
+    ScopedListen listen2{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime.addSecs(2) };
+    ScopedListen listen3{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime.addSecs(3) };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt) };
+        auto artists{ Listen::getTopArtists(session, user->getId(), ScrobblingBackend::Internal, {}, std::nullopt) };
         ASSERT_EQ(artists.results.size(), 2);
         EXPECT_EQ(artists.results[0], artist2->getId());
         EXPECT_EQ(artists.results[1], artist1->getId());
@@ -243,7 +243,7 @@ TEST_F(DatabaseFixture, Listen_getTopArtists_multi)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt, Range {0, 1}) };
+        auto artists{ Listen::getTopArtists(session, user->getId(), ScrobblingBackend::Internal, {}, std::nullopt, Range {0, 1}) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.moreResults, true);
         EXPECT_EQ(artists.results[0], artist2->getId());
@@ -256,7 +256,7 @@ TEST_F(DatabaseFixture, Listen_getTopArtists_cluster)
     ScopedUser user{ session, "MyUser" };
     ScopedArtist artist{ session, "MyArtist" };
     const Wt::WDateTime dateTime{ Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1} };
-    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime };
     ScopedClusterType clusterType{ session, "MyType" };
     ScopedCluster cluster{ session, clusterType.lockAndGet(), "MyCluster" };
 
@@ -268,7 +268,7 @@ TEST_F(DatabaseFixture, Listen_getTopArtists_cluster)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {cluster.getId()}, std::nullopt) };
+        auto artists{ Listen::getTopArtists(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}, std::nullopt) };
         ASSERT_EQ(artists.results.size(), 0);
     }
     {
@@ -278,7 +278,7 @@ TEST_F(DatabaseFixture, Listen_getTopArtists_cluster)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {cluster.getId()}, std::nullopt) };
+        auto artists{ Listen::getTopArtists(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}, std::nullopt) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results[0], artist.getId());
     }
@@ -291,24 +291,24 @@ TEST_F(DatabaseFixture, Listen_getTopReleases)
     const Wt::WDateTime dateTime{ Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1} };
     ScopedRelease release{ session, "MyRelease" };
     {
-        auto transaction{ session.createSharedTransaction() };
+        auto transaction{ session.createUniqueTransaction() };
         track.get().modify()->setRelease(release.get());
     }
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {}) };
+        auto releases{ Listen::getTopReleases(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(releases.moreResults, false);
         EXPECT_EQ(releases.results.size(), 0);
     }
 
-    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {}) };
+        auto releases{ Listen::getTopReleases(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(releases.moreResults, false);
         ASSERT_EQ(releases.results.size(), 1);
         EXPECT_EQ(releases.results[0], release.getId());
@@ -316,7 +316,7 @@ TEST_F(DatabaseFixture, Listen_getTopReleases)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getTopReleases(session, user->getId(), Scrobbler::ListenBrainz, {}) };
+        auto releases{ Listen::getTopReleases(session, user->getId(), ScrobblingBackend::ListenBrainz, {}) };
         EXPECT_EQ(releases.moreResults, false);
         EXPECT_EQ(releases.results.size(), 0);
     }
@@ -328,12 +328,12 @@ TEST_F(DatabaseFixture, Listen_getTopReleases_multi)
     ScopedTrack track2{ session, "MyTrack" };
     ScopedUser user{ session, "MyUser" };
     const Wt::WDateTime dateTime{ Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1} };
-    ScopedListen listen1{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen1{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime };
     ScopedRelease release1{ session, "MyRelease1" };
     ScopedRelease release2{ session, "MyRelease2" };
 
     {
-        auto transaction{ session.createSharedTransaction() };
+        auto transaction{ session.createUniqueTransaction() };
         track1.get().modify()->setRelease(release1.get());
         track2.get().modify()->setRelease(release2.get());
     }
@@ -341,28 +341,28 @@ TEST_F(DatabaseFixture, Listen_getTopReleases_multi)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {}) };
+        auto releases{ Listen::getTopReleases(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(releases.moreResults, false);
         ASSERT_EQ(releases.results.size(), 1);
         EXPECT_EQ(releases.results[0], release1.getId());
     }
-    ScopedListen listen2{ session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime };
-    ScopedListen listen3{ session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen2{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime };
+    ScopedListen listen3{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {}) };
+        auto releases{ Listen::getTopReleases(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(releases.moreResults, false);
         ASSERT_EQ(releases.results.size(), 2);
         EXPECT_EQ(releases.results[0], release2.getId());
         EXPECT_EQ(releases.results[1], release1.getId());
     }
-    ScopedListen listen4{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime };
-    ScopedListen listen5{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen4{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime };
+    ScopedListen listen5{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {}) };
+        auto releases{ Listen::getTopReleases(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(releases.moreResults, false);
         ASSERT_EQ(releases.results.size(), 2);
         EXPECT_EQ(releases.results[0], release1.getId());
@@ -375,20 +375,20 @@ TEST_F(DatabaseFixture, Listen_getTopReleases_cluster)
     ScopedTrack track{ session, "MyTrack" };
     ScopedUser user{ session, "MyUser" };
     const Wt::WDateTime dateTime{ Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1} };
-    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime };
     ScopedClusterType clusterType{ session, "MyType" };
     ScopedCluster cluster{ session, clusterType.lockAndGet(), "MyCluster" };
     ScopedRelease release{ session, "MyRelease" };
 
     {
-        auto transaction{ session.createSharedTransaction() };
+        auto transaction{ session.createUniqueTransaction() };
         track.get().modify()->setRelease(release.get());
     }
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {cluster.getId()}) };
+        auto releases{ Listen::getTopReleases(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}) };
         EXPECT_EQ(releases.results.size(), 0);
     }
     {
@@ -399,7 +399,7 @@ TEST_F(DatabaseFixture, Listen_getTopReleases_cluster)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {cluster.getId()}) };
+        auto releases{ Listen::getTopReleases(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}) };
         EXPECT_EQ(releases.results.size(), 1);
         EXPECT_EQ(releases.results[0], release.getId());
     }
@@ -414,17 +414,17 @@ TEST_F(DatabaseFixture, Listen_getTopTracks)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {}) };
+        auto tracks{ Listen::getTopTracks(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         ASSERT_EQ(tracks.results.size(), 0);
     }
 
-    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {}) };
+        auto tracks{ Listen::getTopTracks(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         ASSERT_EQ(tracks.results.size(), 1);
         EXPECT_EQ(tracks.results[0], track.getId());
@@ -432,7 +432,7 @@ TEST_F(DatabaseFixture, Listen_getTopTracks)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getTopTracks(session, user->getId(), Scrobbler::ListenBrainz, {}) };
+        auto tracks{ Listen::getTopTracks(session, user->getId(), ScrobblingBackend::ListenBrainz, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         EXPECT_EQ(tracks.results.size(), 0);
     }
@@ -444,33 +444,33 @@ TEST_F(DatabaseFixture, Listen_getTopTrack_multi)
     ScopedTrack track2{ session, "MyTrack2" };
     ScopedUser user{ session, "MyUser" };
     const Wt::WDateTime dateTime{ Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1} };
-    ScopedListen listen1{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen1{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {}) };
+        auto tracks{ Listen::getTopTracks(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         ASSERT_EQ(tracks.results.size(), 1);
         EXPECT_EQ(tracks.results[0], track1.getId());
     }
-    ScopedListen listen2{ session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime };
-    ScopedListen listen3{ session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen2{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime };
+    ScopedListen listen3{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {}) };
+        auto tracks{ Listen::getTopTracks(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         ASSERT_EQ(tracks.results.size(), 2);
         EXPECT_EQ(tracks.results[0], track2.getId());
         EXPECT_EQ(tracks.results[1], track1.getId());
     }
-    ScopedListen listen4{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime };
-    ScopedListen listen5{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen4{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime };
+    ScopedListen listen5{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {}) };
+        auto tracks{ Listen::getTopTracks(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         ASSERT_EQ(tracks.results.size(), 2);
         EXPECT_EQ(tracks.results[0], track1.getId());
@@ -483,14 +483,14 @@ TEST_F(DatabaseFixture, Listen_getTopTracks_cluster)
     ScopedTrack track{ session, "MyTrack" };
     ScopedUser user{ session, "MyUser" };
     const Wt::WDateTime dateTime{ Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1} };
-    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime };
     ScopedClusterType clusterType{ session, "MyType" };
     ScopedCluster cluster{ session, clusterType.lockAndGet(), "MyCluster" };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {cluster.getId()}) };
+        auto tracks{ Listen::getTopTracks(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}) };
         EXPECT_EQ(tracks.results.size(), 0);
     }
     {
@@ -501,7 +501,7 @@ TEST_F(DatabaseFixture, Listen_getTopTracks_cluster)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {cluster.getId()}) };
+        auto tracks{ Listen::getTopTracks(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}) };
         EXPECT_EQ(tracks.results.size(), 1);
         EXPECT_EQ(tracks.results[0], track.getId());
     }
@@ -521,31 +521,31 @@ TEST_F(DatabaseFixture, Listen_getRecentArtists)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt) };
+        auto artists{ Listen::getRecentArtists(session, user->getId(), ScrobblingBackend::Internal, {}, std::nullopt) };
         EXPECT_EQ(artists.results.size(), 0);
         EXPECT_EQ(artists.moreResults, false);
     }
 
     const Wt::WDateTime dateTime{ Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1} };
-    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt) };
+        auto artists{ Listen::getRecentArtists(session, user->getId(), ScrobblingBackend::Internal, {}, std::nullopt) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results[0], artist->getId());
     }
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getRecentArtists(session, user->getId(), Scrobbler::ListenBrainz, {}, std::nullopt) };
+        auto artists{ Listen::getRecentArtists(session, user->getId(), ScrobblingBackend::ListenBrainz, {}, std::nullopt) };
         ASSERT_EQ(artists.results.size(), 0);
     }
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, TrackArtistLinkType::Producer) };
+        auto artists{ Listen::getRecentArtists(session, user->getId(), ScrobblingBackend::Internal, {}, TrackArtistLinkType::Producer) };
         EXPECT_EQ(artists.results.size(), 0);
     }
     {
@@ -555,7 +555,7 @@ TEST_F(DatabaseFixture, Listen_getRecentArtists)
         {
             auto transaction{ session.createSharedTransaction() };
 
-            auto artists{ Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {cluster->getId()}, std::nullopt) };
+            auto artists{ Listen::getRecentArtists(session, user->getId(), ScrobblingBackend::Internal, {cluster->getId()}, std::nullopt) };
             EXPECT_EQ(artists.results.size(), 0);
         }
     }
@@ -579,32 +579,32 @@ TEST_F(DatabaseFixture, Listen_getRecentArtists_multi)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt) };
+        auto artists{ Listen::getRecentArtists(session, user->getId(), ScrobblingBackend::Internal, {}, std::nullopt) };
         EXPECT_EQ(artists.results.size(), 0);
     }
 
-    ScopedListen listen1{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(1) };
+    ScopedListen listen1{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime.addSecs(1) };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt) };
+        auto artists{ Listen::getRecentArtists(session, user->getId(), ScrobblingBackend::Internal, {}, std::nullopt) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results[0], artist1->getId());
     }
-    ScopedListen listen2{ session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(2) };
+    ScopedListen listen2{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime.addSecs(2) };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt) };
+        auto artists{ Listen::getRecentArtists(session, user->getId(), ScrobblingBackend::Internal, {}, std::nullopt) };
         ASSERT_EQ(artists.results.size(), 2);
         EXPECT_EQ(artists.results[0], artist2->getId());
         EXPECT_EQ(artists.results[1], artist1->getId());
     }
-    ScopedListen listen3{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(-1) };
+    ScopedListen listen3{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime.addSecs(-1) };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt, Range {0, 1}) };
+        auto artists{ Listen::getRecentArtists(session, user->getId(), ScrobblingBackend::Internal, {}, std::nullopt, Range {0, 1}) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.moreResults, true);
         EXPECT_EQ(artists.results[0], artist2->getId());
@@ -617,7 +617,7 @@ TEST_F(DatabaseFixture, Listen_getRecentArtists_cluster)
     ScopedUser user{ session, "MyUser" };
     ScopedArtist artist{ session, "MyArtist" };
     const Wt::WDateTime dateTime{ Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1} };
-    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime };
     ScopedClusterType clusterType{ session, "MyType" };
     ScopedCluster cluster{ session, clusterType.lockAndGet(), "MyCluster" };
 
@@ -629,7 +629,7 @@ TEST_F(DatabaseFixture, Listen_getRecentArtists_cluster)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {cluster.getId()}, std::nullopt) };
+        auto artists{ Listen::getRecentArtists(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}, std::nullopt) };
         ASSERT_EQ(artists.results.size(), 0);
     }
     {
@@ -639,7 +639,7 @@ TEST_F(DatabaseFixture, Listen_getRecentArtists_cluster)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto artists{ Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {cluster.getId()}, std::nullopt) };
+        auto artists{ Listen::getRecentArtists(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}, std::nullopt) };
         ASSERT_EQ(artists.results.size(), 1);
         EXPECT_EQ(artists.results[0], artist.getId());
     }
@@ -652,25 +652,25 @@ TEST_F(DatabaseFixture, Listen_getRecentReleases)
     ScopedRelease release{ session, "MyRelease" };
 
     {
-        auto transaction{ session.createSharedTransaction() };
+        auto transaction{ session.createUniqueTransaction() };
         track.get().modify()->setRelease(release.get());
     }
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {}) };
+        auto releases{ Listen::getRecentReleases(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(releases.moreResults, false);
         ASSERT_EQ(releases.results.size(), 0);
     }
 
     const Wt::WDateTime dateTime{ Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1} };
-    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {}) };
+        auto releases{ Listen::getRecentReleases(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(releases.moreResults, false);
         ASSERT_EQ(releases.results.size(), 1);
         EXPECT_EQ(releases.results[0], release.getId());
@@ -678,7 +678,7 @@ TEST_F(DatabaseFixture, Listen_getRecentReleases)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getRecentReleases(session, user->getId(), Scrobbler::ListenBrainz, {}) };
+        auto releases{ Listen::getRecentReleases(session, user->getId(), ScrobblingBackend::ListenBrainz, {}) };
         EXPECT_EQ(releases.moreResults, false);
         EXPECT_EQ(releases.results.size(), 0);
     }
@@ -692,46 +692,46 @@ TEST_F(DatabaseFixture, Listen_getMostRecentRelease)
     ScopedRelease release{ session, "MyRelease" };
 
     {
-        auto transaction{ session.createSharedTransaction() };
+        auto transaction{ session.createUniqueTransaction() };
         track.get().modify()->setRelease(release.get());
     }
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        const auto listen{ Listen::getMostRecentListen(session, user->getId(), Scrobbler::Internal, release.getId()) };
+        const auto listen{ Listen::getMostRecentListen(session, user->getId(), ScrobblingBackend::Internal, release.getId()) };
         EXPECT_FALSE(listen);
     }
 
     const Wt::WDateTime dateTime1{ Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1} };
-    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime1 };
+    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime1 };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        const auto listen{ Listen::getMostRecentListen(session, user->getId(), Scrobbler::Internal, release.getId()) };
+        const auto listen{ Listen::getMostRecentListen(session, user->getId(), ScrobblingBackend::Internal, release.getId()) };
         EXPECT_TRUE(listen);
         EXPECT_EQ(listen->getDateTime(), dateTime1);
     }
 
     const Wt::WDateTime dateTime2{ Wt::WDate {1999, 1, 2}, Wt::WTime {12,0, 1} };
-    ScopedListen listen2{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime2 };
+    ScopedListen listen2{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime2 };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        const auto listen{ Listen::getMostRecentListen(session, user->getId(), Scrobbler::Internal, release.getId()) };
+        const auto listen{ Listen::getMostRecentListen(session, user->getId(), ScrobblingBackend::Internal, release.getId()) };
         EXPECT_TRUE(listen);
         EXPECT_EQ(listen->getDateTime(), dateTime1);
     }
 
     const Wt::WDateTime dateTime3{ Wt::WDate {2001, 1, 2}, Wt::WTime {12,0, 1} };
-    ScopedListen listen3{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime3 };
+    ScopedListen listen3{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime3 };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        const auto listen{ Listen::getMostRecentListen(session, user->getId(), Scrobbler::Internal, release.getId()) };
+        const auto listen{ Listen::getMostRecentListen(session, user->getId(), ScrobblingBackend::Internal, release.getId()) };
         EXPECT_TRUE(listen);
         EXPECT_EQ(listen->getDateTime(), dateTime3);
     }
@@ -746,50 +746,50 @@ TEST_F(DatabaseFixture, Listen_getRecentReleases_multi)
     ScopedRelease release2{ session, "MyRelease2" };
 
     {
-        auto transaction{ session.createSharedTransaction() };
+        auto transaction{ session.createUniqueTransaction() };
         track1.get().modify()->setRelease(release1.get());
         track2.get().modify()->setRelease(release2.get());
     }
 
     const Wt::WDateTime dateTime{ Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1} };
-    ScopedListen listen1{ session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen1{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {}) };
+        auto releases{ Listen::getRecentReleases(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(releases.moreResults, false);
         ASSERT_EQ(releases.results.size(), 1);
         EXPECT_EQ(releases.results[0], release2.getId());
     }
 
-    ScopedListen listen2{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(1) };
+    ScopedListen listen2{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime.addSecs(1) };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {}) };
+        auto releases{ Listen::getRecentReleases(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(releases.moreResults, false);
         ASSERT_EQ(releases.results.size(), 2);
         EXPECT_EQ(releases.results[0], release1.getId());
         EXPECT_EQ(releases.results[1], release2.getId());
     }
 
-    ScopedListen listen3{ session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(2) };
+    ScopedListen listen3{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime.addSecs(2) };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {}) };
+        auto releases{ Listen::getRecentReleases(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(releases.moreResults, false);
         ASSERT_EQ(releases.results.size(), 2);
         EXPECT_EQ(releases.results[0], release2.getId());
         EXPECT_EQ(releases.results[1], release1.getId());
     }
 
-    ScopedListen listen4{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(-1) };
+    ScopedListen listen4{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime.addSecs(-1) };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {}) };
+        auto releases{ Listen::getRecentReleases(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(releases.moreResults, false);
         ASSERT_EQ(releases.results.size(), 2);
         EXPECT_EQ(releases.results[0], release2.getId());
@@ -806,23 +806,23 @@ TEST_F(DatabaseFixture, Listen_getRecentReleases_cluster)
     ScopedRelease release{ session, "MyRelease" };
 
     {
-        auto transaction{ session.createSharedTransaction() };
+        auto transaction{ session.createUniqueTransaction() };
         track.get().modify()->setRelease(release.get());
     }
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {cluster.getId()}) };
+        auto releases{ Listen::getRecentReleases(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}) };
         EXPECT_EQ(releases.results.size(), 0);
     }
 
     const Wt::WDateTime dateTime{ Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1} };
-    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {cluster.getId()}) };
+        auto releases{ Listen::getRecentReleases(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}) };
         EXPECT_EQ(releases.results.size(), 0);
     }
 
@@ -833,7 +833,7 @@ TEST_F(DatabaseFixture, Listen_getRecentReleases_cluster)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto releases{ Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {cluster.getId()}) };
+        auto releases{ Listen::getRecentReleases(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}) };
         EXPECT_EQ(releases.results.size(), 1);
         EXPECT_EQ(releases.results[0], release.getId());
     }
@@ -847,18 +847,18 @@ TEST_F(DatabaseFixture, Listen_getRecentTracks)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {}) };
+        auto tracks{ Listen::getRecentTracks(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         ASSERT_EQ(tracks.results.size(), 0);
     }
 
     const Wt::WDateTime dateTime{ Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1} };
-    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {}) };
+        auto tracks{ Listen::getRecentTracks(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         ASSERT_EQ(tracks.results.size(), 1);
         EXPECT_EQ(tracks.results[0], track.getId());
@@ -867,12 +867,77 @@ TEST_F(DatabaseFixture, Listen_getRecentTracks)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getRecentTracks(session, user->getId(), Scrobbler::ListenBrainz, {}) };
+        auto tracks{ Listen::getRecentTracks(session, user->getId(), ScrobblingBackend::ListenBrainz, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         EXPECT_EQ(tracks.results.size(), 0);
     }
 }
 
+TEST_F(DatabaseFixture, Listen_getCount_track)
+{
+    ScopedTrack track{ session, "MyTrack" };
+    ScopedUser user{ session, "MyUser" };
+
+    {
+        auto transaction{ session.createSharedTransaction() };
+
+        const std::size_t count{ Listen::getCount(session, user->getId(), ScrobblingBackend::Internal, track.getId()) };
+        EXPECT_EQ(count, 0);
+    }
+
+    const Wt::WDateTime dateTime1{ Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1} };
+    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime1 };
+
+    {
+        auto transaction{ session.createSharedTransaction() };
+
+        const std::size_t count{ Listen::getCount(session, user->getId(), ScrobblingBackend::Internal, track.getId()) };
+        EXPECT_EQ(count, 1);
+    }
+}
+
+TEST_F(DatabaseFixture, Listen_getCount_release)
+{
+    ScopedTrack track1{ session, "MyTrack" };
+    ScopedTrack track2{ session, "MyTrack" };
+    ScopedUser user{ session, "MyUser" };
+    ScopedRelease release{ session, "MyRelease" };
+
+    auto getReleaseListenCount{ [&]
+    {
+        auto transaction{ session.createSharedTransaction() };
+        return Listen::getCount(session, user->getId(), ScrobblingBackend::Internal, release.getId());
+    } };
+
+    EXPECT_EQ(getReleaseListenCount(), 0);
+
+    const Wt::WDateTime dateTime1{ Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1} };
+    ScopedListen listen1{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime1 };
+
+    EXPECT_EQ(getReleaseListenCount(), 0);
+
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        track1.get().modify()->setRelease(release.get());
+    }
+
+    EXPECT_EQ(getReleaseListenCount(), 1);
+
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        track2.get().modify()->setRelease(release.get());
+    }
+
+    EXPECT_EQ(getReleaseListenCount(), 0);
+    ScopedListen listen2{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime1 };
+    EXPECT_EQ(getReleaseListenCount(), 1);
+    ScopedListen listen3{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime1 };
+    EXPECT_EQ(getReleaseListenCount(), 1);
+
+    ScopedListen listen4{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime1 };
+    EXPECT_EQ(getReleaseListenCount(), 2);
+}
+
 TEST_F(DatabaseFixture, Listen_getMostRecentTrack)
 {
     ScopedTrack track{ session, "MyTrack" };
@@ -881,39 +946,39 @@ TEST_F(DatabaseFixture, Listen_getMostRecentTrack)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto listen{ Listen::getMostRecentListen(session, user->getId(), Scrobbler::Internal, track.getId()) };
+        auto listen{ Listen::getMostRecentListen(session, user->getId(), ScrobblingBackend::Internal, track.getId()) };
         EXPECT_FALSE(listen);
     }
 
     const Wt::WDateTime dateTime1{ Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1} };
-    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime1 };
+    ScopedListen listen1{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime1 };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto listen{ Listen::getMostRecentListen(session, user->getId(), Scrobbler::Internal, track.getId()) };
+        auto listen{ Listen::getMostRecentListen(session, user->getId(), ScrobblingBackend::Internal, track.getId()) };
         EXPECT_TRUE(listen);
         EXPECT_EQ(listen->getDateTime(), dateTime1);
     }
 
     const Wt::WDateTime dateTime2{ Wt::WDate {1999, 1, 2}, Wt::WTime {12,0, 1} };
-    ScopedListen listen2{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime2 };
+    ScopedListen listen2{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime2 };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto listen{ Listen::getMostRecentListen(session, user->getId(), Scrobbler::Internal, track.getId()) };
+        auto listen{ Listen::getMostRecentListen(session, user->getId(), ScrobblingBackend::Internal, track.getId()) };
         EXPECT_TRUE(listen);
         EXPECT_EQ(listen->getDateTime(), dateTime1);
     }
 
     const Wt::WDateTime dateTime3{ Wt::WDate {2001, 1, 2}, Wt::WTime {12,0, 1} };
-    ScopedListen listen3{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime3 };
+    ScopedListen listen3{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime3 };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto listen{ Listen::getMostRecentListen(session, user->getId(), Scrobbler::Internal, track.getId()) };
+        auto listen{ Listen::getMostRecentListen(session, user->getId(), ScrobblingBackend::Internal, track.getId()) };
         EXPECT_TRUE(listen);
         EXPECT_EQ(listen->getDateTime(), dateTime3);
     }
@@ -926,44 +991,44 @@ TEST_F(DatabaseFixture, Listen_getRecentTracks_multi)
     ScopedUser user{ session, "MyUser" };
 
     const Wt::WDateTime dateTime{ Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1} };
-    ScopedListen listen1{ session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen1{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {}) };
+        auto tracks{ Listen::getRecentTracks(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         ASSERT_EQ(tracks.results.size(), 1);
         EXPECT_EQ(tracks.results[0], track2.getId());
     }
 
-    ScopedListen listen2{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(1) };
+    ScopedListen listen2{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime.addSecs(1) };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {}) };
+        auto tracks{ Listen::getRecentTracks(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         ASSERT_EQ(tracks.results.size(), 2);
         EXPECT_EQ(tracks.results[0], track1.getId());
         EXPECT_EQ(tracks.results[1], track2.getId());
     }
 
-    ScopedListen listen3{ session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(2) };
+    ScopedListen listen3{ session, user.lockAndGet(), track2.lockAndGet(), ScrobblingBackend::Internal, dateTime.addSecs(2) };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {}) };
+        auto tracks{ Listen::getRecentTracks(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         ASSERT_EQ(tracks.results.size(), 2);
         EXPECT_EQ(tracks.results[0], track2.getId());
         EXPECT_EQ(tracks.results[1], track1.getId());
     }
 
-    ScopedListen listen4{ session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(-1) };
+    ScopedListen listen4{ session, user.lockAndGet(), track1.lockAndGet(), ScrobblingBackend::Internal, dateTime.addSecs(-1) };
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {}) };
+        auto tracks{ Listen::getRecentTracks(session, user->getId(), ScrobblingBackend::Internal, {}) };
         EXPECT_EQ(tracks.moreResults, false);
         ASSERT_EQ(tracks.results.size(), 2);
         EXPECT_EQ(tracks.results[0], track2.getId());
@@ -976,14 +1041,14 @@ TEST_F(DatabaseFixture, Listen_getRecentTracks_cluster)
     ScopedTrack track{ session, "MyTrack" };
     ScopedUser user{ session, "MyUser" };
     const Wt::WDateTime dateTime{ Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1} };
-    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime };
+    ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime };
     ScopedClusterType clusterType{ session, "MyType" };
     ScopedCluster cluster{ session, clusterType.lockAndGet(), "MyCluster" };
 
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {cluster.getId()}) };
+        auto tracks{ Listen::getRecentTracks(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}) };
         EXPECT_EQ(tracks.results.size(), 0);
     }
     {
@@ -994,7 +1059,7 @@ TEST_F(DatabaseFixture, Listen_getRecentTracks_cluster)
     {
         auto transaction{ session.createSharedTransaction() };
 
-        auto tracks{ Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {cluster.getId()}) };
+        auto tracks{ Listen::getRecentTracks(session, user->getId(), ScrobblingBackend::Internal, {cluster.getId()}) };
         EXPECT_EQ(tracks.results.size(), 1);
         EXPECT_EQ(tracks.results[0], track.getId());
     }
diff --git a/src/libs/services/database/test/Release.cpp b/src/libs/services/database/test/Release.cpp
index 9c153fc4..cb3a35b2 100644
--- a/src/libs/services/database/test/Release.cpp
+++ b/src/libs/services/database/test/Release.cpp
@@ -23,580 +23,586 @@ using namespace Database;
 
 TEST_F(DatabaseFixture, Release)
 {
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		EXPECT_EQ(Release::getCount(session), 0);
-		EXPECT_FALSE(Release::exists(session, 0));
-		EXPECT_FALSE(Release::exists(session, 1));
-	}
+        EXPECT_EQ(Release::getCount(session), 0);
+        EXPECT_FALSE(Release::exists(session, 0));
+        EXPECT_FALSE(Release::exists(session, 1));
+    }
 
-	ScopedRelease release {session, "MyRelease"};
+    ScopedRelease release{ session, "MyRelease" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		EXPECT_EQ(Release::getCount(session), 1);
-		EXPECT_TRUE(Release::exists(session, release.getId()));
+        EXPECT_EQ(Release::getCount(session), 1);
+        EXPECT_TRUE(Release::exists(session, release.getId()));
 
-		{
-			auto releases {Release::findOrphans(session, Range {})};
-			ASSERT_EQ(releases.results.size(), 1);
-			EXPECT_EQ(releases.results.front(), release.getId());
-		}
+        {
+            const auto releases{ Release::findOrphanIds(session, Range {}) };
+            ASSERT_EQ(releases.results.size(), 1);
+            EXPECT_EQ(releases.results.front(), release.getId());
+        }
 
-		{
-			auto releases {Release::find(session, Release::FindParameters {})};
-			ASSERT_EQ(releases.results.size(), 1);
-			EXPECT_EQ(releases.results.front(), release.getId());
-			EXPECT_EQ(release->getDuration(), std::chrono::seconds {0});
-		}
-	}
+        {
+            const auto releases{ Release::findIds(session, Release::FindParameters {}) };
+            ASSERT_EQ(releases.results.size(), 1);
+            EXPECT_EQ(releases.results.front(), release.getId());
+            EXPECT_EQ(release->getDuration(), std::chrono::seconds{ 0 });
+        }
+
+        {
+            const auto releases{ Release::find(session, Release::FindParameters {}) };
+            ASSERT_EQ(releases.results.size(), 1);
+            EXPECT_EQ(releases.results.front()->getId(), release.getId());
+        }
+    }
 }
 
 TEST_F(DatabaseFixture, Release_singleTrack)
 {
-	ScopedRelease release {session, "MyRelease"};
+    ScopedRelease release{ session, "MyRelease" };
 
-	{
-		ScopedTrack track {session, "MyTrack"};
-		{
-			auto transaction {session.createUniqueTransaction()};
+    {
+        ScopedTrack track{ session, "MyTrack" };
+        {
+            auto transaction{ session.createUniqueTransaction() };
 
-			track.get().modify()->setRelease(release.get());
-			track.get().modify()->setName("MyTrackName");
-			release.get().modify()->setName("MyReleaseName");
-		}
+            track.get().modify()->setRelease(release.get());
+            track.get().modify()->setName("MyTrackName");
+            release.get().modify()->setName("MyReleaseName");
+        }
 
-		{
-			auto transaction {session.createSharedTransaction()};
-			EXPECT_TRUE(Release::findOrphans(session, Range {}).results.empty());
+        {
+            auto transaction{ session.createSharedTransaction() };
+            EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
 
-			const auto tracks {Track::find(session, Track::FindParameters {}.setRelease(release.getId()))};
-			ASSERT_EQ(tracks.results.size(), 1);
-			EXPECT_EQ(tracks.results.front(), track.getId());
-		}
+            const auto tracks{ Track::findIds(session, Track::FindParameters {}.setRelease(release.getId())) };
+            ASSERT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.results.front(), track.getId());
+        }
 
-		{
-			auto transaction {session.createUniqueTransaction()};
+        {
+            auto transaction{ session.createUniqueTransaction() };
 
-			ASSERT_TRUE(track->getRelease());
-			EXPECT_EQ(track->getRelease()->getId(), release.getId());
-		}
+            ASSERT_TRUE(track->getRelease());
+            EXPECT_EQ(track->getRelease()->getId(), release.getId());
+        }
 
-		{
-			auto transaction {session.createUniqueTransaction()};
-			auto tracks {Track::find(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseName"))};
-			ASSERT_EQ(tracks.results.size(), 1);
-			EXPECT_EQ(tracks.results.front(), track.getId());
-		}
-		{
-			auto transaction {session.createUniqueTransaction()};
-			auto tracks {Track::find(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseFoo"))};
-			EXPECT_EQ(tracks.results.size(), 0);
-		}
-		{
-			auto transaction {session.createUniqueTransaction()};
-			auto tracks {Track::find(session, Track::FindParameters{}.setName("MyTrackFoo").setReleaseName("MyReleaseName"))};
-			EXPECT_EQ(tracks.results.size(), 0);
-		}
-	}
+        {
+            auto transaction{ session.createUniqueTransaction() };
+            auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseName")) };
+            ASSERT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.results.front(), track.getId());
+        }
+        {
+            auto transaction{ session.createUniqueTransaction() };
+            auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseFoo")) };
+            EXPECT_EQ(tracks.results.size(), 0);
+        }
+        {
+            auto transaction{ session.createUniqueTransaction() };
+            auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackFoo").setReleaseName("MyReleaseName")) };
+            EXPECT_EQ(tracks.results.size(), 0);
+        }
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		const auto tracks {Track::find(session, Track::FindParameters {}.setRelease(release.getId()))};
-		EXPECT_TRUE(tracks.results.empty());
+        const auto tracks{ Track::findIds(session, Track::FindParameters {}.setRelease(release.getId())) };
+        EXPECT_TRUE(tracks.results.empty());
 
-		auto releases {Release::findOrphans(session, Range {})};
-		ASSERT_EQ(releases.results.size(), 1);
-		EXPECT_EQ(releases.results.front(), release.getId());
-	}
+        auto releases{ Release::findOrphanIds(session, Range {}) };
+        ASSERT_EQ(releases.results.size(), 1);
+        EXPECT_EQ(releases.results.front(), release.getId());
+    }
 }
 
 TEST_F(DatabaseFixture, MulitpleReleaseSearchByName)
 {
-	ScopedRelease release1 {session, "MyRelease"};
-	ScopedRelease release2 {session, "MyRelease%"};
-	ScopedRelease release3 {session, "%MyRelease"};
-	ScopedRelease release4 {session, "MyRelease%Foo"};
-	ScopedRelease release5 {session, "Foo%MyRelease"};
-	ScopedRelease release6 {session, "_yRelease"};
+    ScopedRelease release1{ session, "MyRelease" };
+    ScopedRelease release2{ session, "MyRelease%" };
+    ScopedRelease release3{ session, "%MyRelease" };
+    ScopedRelease release4{ session, "MyRelease%Foo" };
+    ScopedRelease release5{ session, "Foo%MyRelease" };
+    ScopedRelease release6{ session, "_yRelease" };
 
-	// filters does not work on orphans
-	ScopedTrack track1 {session, "MyTrack"};
-	ScopedTrack track2 {session, "MyTrack"};
-	ScopedTrack track3 {session, "MyTrack"};
-	ScopedTrack track4 {session, "MyTrack"};
-	ScopedTrack track5 {session, "MyTrack"};
-	ScopedTrack track6 {session, "MyTrack"};
+    // filters does not work on orphans
+    ScopedTrack track1{ session, "MyTrack" };
+    ScopedTrack track2{ session, "MyTrack" };
+    ScopedTrack track3{ session, "MyTrack" };
+    ScopedTrack track4{ session, "MyTrack" };
+    ScopedTrack track5{ session, "MyTrack" };
+    ScopedTrack track6{ session, "MyTrack" };
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		track1.get().modify()->setRelease(release1.get());
-		track2.get().modify()->setRelease(release2.get());
-		track3.get().modify()->setRelease(release3.get());
-		track4.get().modify()->setRelease(release4.get());
-		track5.get().modify()->setRelease(release5.get());
-		track6.get().modify()->setRelease(release6.get());
-	}
+        track1.get().modify()->setRelease(release1.get());
+        track2.get().modify()->setRelease(release2.get());
+        track3.get().modify()->setRelease(release3.get());
+        track4.get().modify()->setRelease(release4.get());
+        track5.get().modify()->setRelease(release5.get());
+        track6.get().modify()->setRelease(release6.get());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		{
-			const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"Release"}))};
-			EXPECT_EQ(releases.results.size(), 6);
-		}
+        {
+            const auto releases{ Release::findIds(session, Release::FindParameters {}.setKeywords({"Release"})) };
+            EXPECT_EQ(releases.results.size(), 6);
+        }
 
-		{
-			const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"MyRelease"}))};
-			ASSERT_EQ(releases.results.size(), 5);
-			EXPECT_TRUE(std::none_of(std::cbegin(releases.results), std::cend(releases.results), [&](const ReleaseId releaseId) { return releaseId == release6.getId(); }));
-		}
-		{
-			const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"MyRelease%"}))};
-			ASSERT_EQ(releases.results.size(), 2);
-			EXPECT_EQ(releases.results[0], release2.getId());
-			EXPECT_EQ(releases.results[1], release4.getId());
-		}
-		{
-			const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"%MyRelease"}))};
-			ASSERT_EQ(releases.results.size(), 2);
-			EXPECT_EQ(releases.results[0], release3.getId());
-			EXPECT_EQ(releases.results[1], release5.getId());
-		}
-		{
-			const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"Foo%MyRelease"}))};
-			ASSERT_EQ(releases.results.size(), 1);
-			EXPECT_EQ(releases.results[0], release5.getId());
-		}
-		{
-			const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"MyRelease%Foo"}))};
-			ASSERT_EQ(releases.results.size(), 1);
-			EXPECT_EQ(releases.results[0], release4.getId());
-		}
-	}
+        {
+            const auto releases{ Release::findIds(session, Release::FindParameters {}.setKeywords({"MyRelease"})) };
+            ASSERT_EQ(releases.results.size(), 5);
+            EXPECT_TRUE(std::none_of(std::cbegin(releases.results), std::cend(releases.results), [&](const ReleaseId releaseId) { return releaseId == release6.getId(); }));
+        }
+        {
+            const auto releases{ Release::findIds(session, Release::FindParameters {}.setKeywords({"MyRelease%"})) };
+            ASSERT_EQ(releases.results.size(), 2);
+            EXPECT_EQ(releases.results[0], release2.getId());
+            EXPECT_EQ(releases.results[1], release4.getId());
+        }
+        {
+            const auto releases{ Release::findIds(session, Release::FindParameters {}.setKeywords({"%MyRelease"})) };
+            ASSERT_EQ(releases.results.size(), 2);
+            EXPECT_EQ(releases.results[0], release3.getId());
+            EXPECT_EQ(releases.results[1], release5.getId());
+        }
+        {
+            const auto releases{ Release::findIds(session, Release::FindParameters {}.setKeywords({"Foo%MyRelease"})) };
+            ASSERT_EQ(releases.results.size(), 1);
+            EXPECT_EQ(releases.results[0], release5.getId());
+        }
+        {
+            const auto releases{ Release::findIds(session, Release::FindParameters {}.setKeywords({"MyRelease%Foo"})) };
+            ASSERT_EQ(releases.results.size(), 1);
+            EXPECT_EQ(releases.results[0], release4.getId());
+        }
+    }
 }
 
 TEST_F(DatabaseFixture, MultiTracksSingleReleaseTotalDiscTrack)
 {
-	ScopedRelease release1 {session, "MyRelease"};
+    ScopedRelease release1{ session, "MyRelease" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		EXPECT_FALSE(release1->getTotalDisc());
-	}
+        EXPECT_FALSE(release1->getTotalDisc());
+    }
 
-	ScopedTrack track1 {session, "MyTrack"};
-	{
-		auto transaction {session.createUniqueTransaction()};
+    ScopedTrack track1{ session, "MyTrack" };
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		track1.get().modify()->setRelease(release1.get());
-	}
+        track1.get().modify()->setRelease(release1.get());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		EXPECT_FALSE(release1->getTotalDisc());
-	}
+        EXPECT_FALSE(release1->getTotalDisc());
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		track1.get().modify()->setTotalTrack(36);
-		release1.get().modify()->setTotalDisc(6);
-	}
+        track1.get().modify()->setTotalTrack(36);
+        release1.get().modify()->setTotalDisc(6);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		ASSERT_TRUE(track1->getTotalTrack());
-		EXPECT_EQ(*track1->getTotalTrack(), 36);
-		ASSERT_TRUE(release1->getTotalDisc());
-		EXPECT_EQ(*release1->getTotalDisc(), 6);
-	}
+        ASSERT_TRUE(track1->getTotalTrack());
+        EXPECT_EQ(*track1->getTotalTrack(), 36);
+        ASSERT_TRUE(release1->getTotalDisc());
+        EXPECT_EQ(*release1->getTotalDisc(), 6);
+    }
 
-	ScopedTrack track2 {session, "MyTrack2"};
-	{
-		auto transaction {session.createUniqueTransaction()};
+    ScopedTrack track2{ session, "MyTrack2" };
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		track2.get().modify()->setRelease(release1.get());
-		track2.get().modify()->setTotalTrack(37);
-		release1.get().modify()->setTotalDisc(67);
-	}
+        track2.get().modify()->setRelease(release1.get());
+        track2.get().modify()->setTotalTrack(37);
+        release1.get().modify()->setTotalDisc(67);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		ASSERT_TRUE(track1->getTotalTrack());
-		EXPECT_EQ(*track1->getTotalTrack(), 36);
-		ASSERT_TRUE(release1->getTotalDisc());
-		EXPECT_EQ(*release1->getTotalDisc(), 67);
-	}
+        ASSERT_TRUE(track1->getTotalTrack());
+        EXPECT_EQ(*track1->getTotalTrack(), 36);
+        ASSERT_TRUE(release1->getTotalDisc());
+        EXPECT_EQ(*release1->getTotalDisc(), 67);
+    }
 
-	ScopedRelease release2 {session, "MyRelease2"};
-	{
-		auto transaction {session.createSharedTransaction()};
+    ScopedRelease release2{ session, "MyRelease2" };
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		EXPECT_FALSE(release2->getTotalDisc());
-	}
+        EXPECT_FALSE(release2->getTotalDisc());
+    }
 
-	ScopedTrack track3 {session, "MyTrack3"};
-	{
-		auto transaction {session.createUniqueTransaction()};
+    ScopedTrack track3{ session, "MyTrack3" };
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		track3.get().modify()->setRelease(release2.get());
-		track3.get().modify()->setTotalTrack(7);
-		release2.get().modify()->setTotalDisc(5);
-	}
-	{
-		auto transaction {session.createSharedTransaction()};
+        track3.get().modify()->setRelease(release2.get());
+        track3.get().modify()->setTotalTrack(7);
+        release2.get().modify()->setTotalDisc(5);
+    }
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		ASSERT_TRUE(track1->getTotalTrack());
-		EXPECT_EQ(*track1->getTotalTrack(), 36);
-		ASSERT_TRUE(release1->getTotalDisc());
-		EXPECT_EQ(*release2->getTotalDisc(), 5);
-		ASSERT_TRUE(track3->getTotalTrack());
-		EXPECT_EQ(*track3->getTotalTrack(), 7);
-		ASSERT_TRUE(release2->getTotalDisc());
-		EXPECT_EQ(*release2->getTotalDisc(), 5);
-	}
+        ASSERT_TRUE(track1->getTotalTrack());
+        EXPECT_EQ(*track1->getTotalTrack(), 36);
+        ASSERT_TRUE(release1->getTotalDisc());
+        EXPECT_EQ(*release2->getTotalDisc(), 5);
+        ASSERT_TRUE(track3->getTotalTrack());
+        EXPECT_EQ(*track3->getTotalTrack(), 7);
+        ASSERT_TRUE(release2->getTotalDisc());
+        EXPECT_EQ(*release2->getTotalDisc(), 5);
+    }
 }
 
 TEST_F(DatabaseFixture, MultiTracksSingleReleaseFirstTrack)
 {
-	ScopedRelease release1 {session, "MyRelease1"};
-	ScopedRelease release2 {session, "MyRelease2"};
+    ScopedRelease release1{ session, "MyRelease1" };
+    ScopedRelease release2{ session, "MyRelease2" };
 
-	ScopedTrack track1A {session, "MyTrack1A"};
-	ScopedTrack track1B {session, "MyTrack1B"};
-	ScopedTrack track2A {session, "MyTrack2A"};
-	ScopedTrack track2B {session, "MyTrack2B"};
+    ScopedTrack track1A{ session, "MyTrack1A" };
+    ScopedTrack track1B{ session, "MyTrack1B" };
+    ScopedTrack track2A{ session, "MyTrack2A" };
+    ScopedTrack track2B{ session, "MyTrack2B" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		EXPECT_TRUE(Track::find(session, Track::FindParameters {}.setRelease(release1.getId())).results.empty());
-		EXPECT_TRUE(Track::find(session, Track::FindParameters {}.setRelease(release2.getId())).results.empty());
-	}
+        EXPECT_TRUE(Track::findIds(session, Track::FindParameters{}.setRelease(release1.getId())).results.empty());
+        EXPECT_TRUE(Track::findIds(session, Track::FindParameters{}.setRelease(release2.getId())).results.empty());
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		track1A.get().modify()->setRelease(release1.get());
-		track1B.get().modify()->setRelease(release1.get());
-		track2A.get().modify()->setRelease(release2.get());
-		track2B.get().modify()->setRelease(release2.get());
+        track1A.get().modify()->setRelease(release1.get());
+        track1B.get().modify()->setRelease(release1.get());
+        track2A.get().modify()->setRelease(release2.get());
+        track2B.get().modify()->setRelease(release2.get());
 
-		track1A.get().modify()->setTrackNumber(1);
-		track1B.get().modify()->setTrackNumber(2);
+        track1A.get().modify()->setTrackNumber(1);
+        track1B.get().modify()->setTrackNumber(2);
 
-		track2A.get().modify()->setDiscNumber(2);
-		track2A.get().modify()->setTrackNumber(1);
-		track2B.get().modify()->setTrackNumber(2);
-		track2B.get().modify()->setDiscNumber(1);
-	}
+        track2A.get().modify()->setDiscNumber(2);
+        track2A.get().modify()->setTrackNumber(1);
+        track2B.get().modify()->setTrackNumber(2);
+        track2B.get().modify()->setDiscNumber(1);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		{
-			const auto tracks {Track::find(session, Track::FindParameters {}.setRelease(release1.getId()).setSortMethod(TrackSortMethod::Release))};
-			ASSERT_FALSE(tracks.results.empty());
-			EXPECT_EQ(tracks.results.front(), track1A.getId());
-		}
+        {
+            const auto tracks{ Track::findIds(session, Track::FindParameters {}.setRelease(release1.getId()).setSortMethod(TrackSortMethod::Release)) };
+            ASSERT_FALSE(tracks.results.empty());
+            EXPECT_EQ(tracks.results.front(), track1A.getId());
+        }
 
-		{
-			const auto tracks {Track::find(session, Track::FindParameters {}.setRelease(release2.getId()).setSortMethod(TrackSortMethod::Release))};
-			ASSERT_FALSE(tracks.results.empty());
-			EXPECT_EQ(tracks.results.front(), track2B.getId());
-		}
-	}
+        {
+            const auto tracks{ Track::findIds(session, Track::FindParameters {}.setRelease(release2.getId()).setSortMethod(TrackSortMethod::Release)) };
+            ASSERT_FALSE(tracks.results.empty());
+            EXPECT_EQ(tracks.results.front(), track2B.getId());
+        }
+    }
 }
 
 TEST_F(DatabaseFixture, MultiTracksSingleReleaseDate)
 {
-	ScopedRelease release1 {session, "MyRelease1"};
-	ScopedRelease release2 {session, "MyRelease2"};
-	const Wt::WDate release1Date {Wt::WDate {1994, 2, 3}};
-	const Wt::WDate release1OriginalDate {Wt::WDate {1993, 4, 5}};
+    ScopedRelease release1{ session, "MyRelease1" };
+    ScopedRelease release2{ session, "MyRelease2" };
+    const Wt::WDate release1Date{ Wt::WDate {1994, 2, 3} };
+    const Wt::WDate release1OriginalDate{ Wt::WDate {1993, 4, 5} };
 
-	ScopedTrack track1A {session, "MyTrack1A"};
-	ScopedTrack track1B {session, "MyTrack1B"};
-	ScopedTrack track2A {session, "MyTrack2A"};
-	ScopedTrack track2B {session, "MyTrack2B"};
+    ScopedTrack track1A{ session, "MyTrack1A" };
+    ScopedTrack track1B{ session, "MyTrack1B" };
+    ScopedTrack track2A{ session, "MyTrack2A" };
+    ScopedTrack track2B{ session, "MyTrack2B" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		const auto releases {Release::find(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(0, 3000)))};
-		EXPECT_EQ(releases.results.size(), 0);
-	}
+        const auto releases{ Release::findIds(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(0, 3000))) };
+        EXPECT_EQ(releases.results.size(), 0);
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		track1A.get().modify()->setRelease(release1.get());
-		track1B.get().modify()->setRelease(release1.get());
-		track2A.get().modify()->setRelease(release2.get());
-		track2B.get().modify()->setRelease(release2.get());
+        track1A.get().modify()->setRelease(release1.get());
+        track1B.get().modify()->setRelease(release1.get());
+        track2A.get().modify()->setRelease(release2.get());
+        track2B.get().modify()->setRelease(release2.get());
 
 
-		track1A.get().modify()->setDate(release1Date);
-		track1B.get().modify()->setDate(release1Date);
-		track1A.get().modify()->setOriginalDate(release1OriginalDate);
-		track1B.get().modify()->setOriginalDate(release1OriginalDate);
+        track1A.get().modify()->setDate(release1Date);
+        track1B.get().modify()->setDate(release1Date);
+        track1A.get().modify()->setOriginalDate(release1OriginalDate);
+        track1B.get().modify()->setOriginalDate(release1OriginalDate);
 
-		EXPECT_EQ(release1.get()->getReleaseDate(), release1Date);
-		EXPECT_EQ(release1.get()->getOriginalReleaseDate(), release1OriginalDate);
-	}
+        EXPECT_EQ(release1.get()->getReleaseDate(), release1Date);
+        EXPECT_EQ(release1.get()->getOriginalReleaseDate(), release1OriginalDate);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto releases {Release::find(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(1950, 2000)))};
-		ASSERT_EQ(releases.results.size(), 1);
-		EXPECT_EQ(releases.results.front(), release1.getId());
+        auto releases{ Release::findIds(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(1950, 2000))) };
+        ASSERT_EQ(releases.results.size(), 1);
+        EXPECT_EQ(releases.results.front(), release1.getId());
 
-		releases = Release::find(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(1994, 1994)));
-		ASSERT_EQ(releases.results.size(), 1);
-		EXPECT_EQ(releases.results.front(), release1.getId());
+        releases = Release::findIds(session, Release::FindParameters{}.setDateRange(DateRange::fromYearRange(1994, 1994)));
+        ASSERT_EQ(releases.results.size(), 1);
+        EXPECT_EQ(releases.results.front(), release1.getId());
 
-		releases = Release::find(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(1993, 1993)));
-		ASSERT_EQ(releases.results.size(), 0);
-	}
+        releases = Release::findIds(session, Release::FindParameters{}.setDateRange(DateRange::fromYearRange(1993, 1993)));
+        ASSERT_EQ(releases.results.size(), 0);
+    }
 }
 
 TEST_F(DatabaseFixture, Release_writtenAfter)
 {
-	ScopedRelease release {session, "MyRelease"};
-	ScopedTrack track {session, "MyTrack"};
+    ScopedRelease release{ session, "MyRelease" };
+    ScopedTrack track{ session, "MyTrack" };
 
-	const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 1}, Wt::WTime {12, 30, 20}};
+    const Wt::WDateTime dateTime{ Wt::WDate {1950, 1, 1}, Wt::WTime {12, 30, 20} };
 
-	{
-		auto transaction {session.createUniqueTransaction()};
-		track.get().modify()->setLastWriteTime(dateTime);
-		track.get().modify()->setRelease(release.get());
-	}
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        track.get().modify()->setLastWriteTime(dateTime);
+        track.get().modify()->setRelease(release.get());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		const auto releases {Release::find(session, Release::FindParameters {})};
-		EXPECT_EQ(releases.results.size(), 1);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        const auto releases{ Release::findIds(session, Release::FindParameters {}) };
+        EXPECT_EQ(releases.results.size(), 1);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		const auto releases {Release::find(session, Release::FindParameters {}.setWrittenAfter(dateTime.addSecs(-1)))};
-		EXPECT_EQ(releases.results.size(), 1);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        const auto releases{ Release::findIds(session, Release::FindParameters {}.setWrittenAfter(dateTime.addSecs(-1))) };
+        EXPECT_EQ(releases.results.size(), 1);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		const auto releases {Release::find(session, Release::FindParameters {}.setWrittenAfter(dateTime.addSecs(+1)))};
-		EXPECT_EQ(releases.results.size(), 0);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        const auto releases{ Release::findIds(session, Release::FindParameters {}.setWrittenAfter(dateTime.addSecs(+1))) };
+        EXPECT_EQ(releases.results.size(), 0);
+    }
 }
 
 TEST_F(DatabaseFixture, Release_artist)
 {
-	ScopedRelease release {session, "MyRelease"};
-	ScopedTrack track {session, "MyTrack"};
-	ScopedArtist artist {session, "MyArtist"};
-	ScopedArtist artist2 {session, "MyArtist2"};
-	{
-		auto transaction {session.createUniqueTransaction()};
-		track.get().modify()->setRelease(release.get());
-	}
+    ScopedRelease release{ session, "MyRelease" };
+    ScopedTrack track{ session, "MyTrack" };
+    ScopedArtist artist{ session, "MyArtist" };
+    ScopedArtist artist2{ session, "MyArtist2" };
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        track.get().modify()->setRelease(release.get());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto releases {Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Artist}))};
-		EXPECT_EQ(releases.results.size(), 0);
+        auto releases{ Release::findIds(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Artist})) };
+        EXPECT_EQ(releases.results.size(), 0);
 
-		releases = Release::find(session, Release::FindParameters {}.setArtist(artist2.getId(), {TrackArtistLinkType::Artist}));
-		EXPECT_EQ(releases.results.size(), 0);
-	}
+        releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist2.getId(), { TrackArtistLinkType::Artist }));
+        EXPECT_EQ(releases.results.size(), 0);
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
-		TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
 
-		auto releases {Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Artist}))};
-		ASSERT_EQ(releases.results.size(), 1);
-		EXPECT_EQ(releases.results.front(), release.getId());
+        auto releases{ Release::findIds(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Artist})) };
+        ASSERT_EQ(releases.results.size(), 1);
+        EXPECT_EQ(releases.results.front(), release.getId());
 
-		releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Artist, TrackArtistLinkType::Mixer}));
-		EXPECT_EQ(releases.results.size(), 1);
-		EXPECT_EQ(releases.results.front(), release.getId());
+        releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Artist, TrackArtistLinkType::Mixer }));
+        EXPECT_EQ(releases.results.size(), 1);
+        EXPECT_EQ(releases.results.front(), release.getId());
 
-		releases = Release::find(session, Release::FindParameters {}.setArtist(artist2.getId(), {TrackArtistLinkType::Artist}));
-		EXPECT_EQ(releases.results.size(), 0);
+        releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist2.getId(), { TrackArtistLinkType::Artist }));
+        EXPECT_EQ(releases.results.size(), 0);
 
-		releases = Release::find(session, Release::FindParameters {}.setArtist(artist2.getId()));
-		EXPECT_EQ(releases.results.size(), 0);
+        releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist2.getId()));
+        EXPECT_EQ(releases.results.size(), 0);
 
-		releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::ReleaseArtist, TrackArtistLinkType::Artist}));
-		ASSERT_EQ(releases.results.size(), 1);
-		EXPECT_EQ(releases.results.front(), release.getId());
+        releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::ReleaseArtist, TrackArtistLinkType::Artist }));
+        ASSERT_EQ(releases.results.size(), 1);
+        EXPECT_EQ(releases.results.front(), release.getId());
 
-		releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId()));
-		ASSERT_EQ(releases.results.size(), 1);
-		EXPECT_EQ(releases.results.front(), release.getId());
+        releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId()));
+        ASSERT_EQ(releases.results.size(), 1);
+        EXPECT_EQ(releases.results.front(), release.getId());
 
-		releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Composer}));
-		EXPECT_EQ(releases.results.size(), 0);
+        releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Composer }));
+        EXPECT_EQ(releases.results.size(), 0);
 
-		releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Composer, TrackArtistLinkType::Mixer}));
-		EXPECT_EQ(releases.results.size(), 0);
+        releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Composer, TrackArtistLinkType::Mixer }));
+        EXPECT_EQ(releases.results.size(), 0);
 
-		releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {}, {TrackArtistLinkType::Artist}));
-		EXPECT_EQ(releases.results.size(), 0);
+        releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId(), {}, { TrackArtistLinkType::Artist }));
+        EXPECT_EQ(releases.results.size(), 0);
 
-		releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {}, {TrackArtistLinkType::Artist, TrackArtistLinkType::Composer}));
-		EXPECT_EQ(releases.results.size(), 0);
-	}
+        releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId(), {}, { TrackArtistLinkType::Artist, TrackArtistLinkType::Composer }));
+        EXPECT_EQ(releases.results.size(), 0);
+    }
 }
 
 TEST_F(DatabaseFixture, Release_getDiscCount)
 {
-	ScopedRelease release {session, "MyRelease"};
-	ScopedTrack track {session, "MyTrack"};
-	ScopedTrack track2 {session, "MyTrack2"};
+    ScopedRelease release{ session, "MyRelease" };
+    ScopedTrack track{ session, "MyTrack" };
+    ScopedTrack track2{ session, "MyTrack2" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_EQ(release.get()->getDiscCount(), 0);
-	}
-	{
-		auto transaction {session.createUniqueTransaction()};
-		track.get().modify()->setRelease(release.get());
-	}
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_EQ(release.get()->getDiscCount(), 0);
-	}
-	{
-		auto transaction {session.createUniqueTransaction()};
-		track.get().modify()->setDiscNumber(5);
-	}
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_EQ(release.get()->getDiscCount(), 1);
-	}
-	{
-		auto transaction {session.createUniqueTransaction()};
-		track2.get().modify()->setRelease(release.get());
-		track2.get().modify()->setDiscNumber(5);
-	}
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_EQ(release.get()->getDiscCount(), 1);
-	}
-	{
-		auto transaction {session.createUniqueTransaction()};
-		track2.get().modify()->setDiscNumber(6);
-	}
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_EQ(release.get()->getDiscCount(), 2);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_EQ(release.get()->getDiscCount(), 0);
+    }
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        track.get().modify()->setRelease(release.get());
+    }
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_EQ(release.get()->getDiscCount(), 0);
+    }
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        track.get().modify()->setDiscNumber(5);
+    }
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_EQ(release.get()->getDiscCount(), 1);
+    }
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        track2.get().modify()->setRelease(release.get());
+        track2.get().modify()->setDiscNumber(5);
+    }
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_EQ(release.get()->getDiscCount(), 1);
+    }
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        track2.get().modify()->setDiscNumber(6);
+    }
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_EQ(release.get()->getDiscCount(), 2);
+    }
 }
 
 TEST_F(DatabaseFixture, Release_releaseType)
 {
-	ScopedRelease release {session, "MyRelease"};
+    ScopedRelease release{ session, "MyRelease" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_EQ(release.get()->getPrimaryType(), std::nullopt);
-		EXPECT_EQ(release.get()->getSecondaryTypes(), EnumSet<ReleaseTypeSecondary> {});
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_EQ(release.get()->getPrimaryType(), std::nullopt);
+        EXPECT_EQ(release.get()->getSecondaryTypes(), EnumSet<ReleaseTypeSecondary> {});
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
-		release.get().modify()->setPrimaryType({ ReleaseTypePrimary::Album });
-		release.get().modify()->setSecondaryTypes({ ReleaseTypeSecondary::Compilation });
-	}
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        release.get().modify()->setPrimaryType({ ReleaseTypePrimary::Album });
+        release.get().modify()->setSecondaryTypes({ ReleaseTypeSecondary::Compilation });
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_EQ(release.get()->getPrimaryType(), ReleaseTypePrimary::Album);
-		EXPECT_TRUE(release.get()->getSecondaryTypes().contains(ReleaseTypeSecondary::Compilation));
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_EQ(release.get()->getPrimaryType(), ReleaseTypePrimary::Album);
+        EXPECT_TRUE(release.get()->getSecondaryTypes().contains(ReleaseTypeSecondary::Compilation));
+    }
 }
 
 TEST_F(DatabaseFixture, ReleaseSortOrder)
 {
-	ScopedRelease release1 {session, "MyRelease1"};
-	const Wt::WDate release1Date {Wt::WDate {2000, 2, 3}};
-	const Wt::WDate release1OriginalDate {Wt::WDate {1993, 4, 5}};
+    ScopedRelease release1{ session, "MyRelease1" };
+    const Wt::WDate release1Date{ Wt::WDate {2000, 2, 3} };
+    const Wt::WDate release1OriginalDate{ Wt::WDate {1993, 4, 5} };
 
-	ScopedRelease release2 {session, "MyRelease2"};
-	const Wt::WDate release2Date {Wt::WDate {1994, 2, 3}};
+    ScopedRelease release2{ session, "MyRelease2" };
+    const Wt::WDate release2Date{ Wt::WDate {1994, 2, 3} };
 
-	ScopedTrack track1 {session, "MyTrack1"};
-	ScopedTrack track2 {session, "MyTrack2"};
+    ScopedTrack track1{ session, "MyTrack1" };
+    ScopedTrack track2{ session, "MyTrack2" };
 
-	ASSERT_LT(release2Date, release1Date);
-	ASSERT_GT(release2Date, release1OriginalDate);
+    ASSERT_LT(release2Date, release1Date);
+    ASSERT_GT(release2Date, release1OriginalDate);
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		track1.get().modify()->setRelease(release1.get());
-		track1.get().modify()->setOriginalDate(release1OriginalDate);
-		track1.get().modify()->setDate(release1Date);
+        track1.get().modify()->setRelease(release1.get());
+        track1.get().modify()->setOriginalDate(release1OriginalDate);
+        track1.get().modify()->setDate(release1Date);
 
-		track2.get().modify()->setRelease(release2.get());
-		track2.get().modify()->setDate(release2Date);
-	}
+        track2.get().modify()->setRelease(release2.get());
+        track2.get().modify()->setDate(release2Date);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		const auto releases {Release::find(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::Name) )};
-		ASSERT_EQ(releases.results.size(), 2);
-		EXPECT_EQ(releases.results.front(), release1.getId());
-		EXPECT_EQ(releases.results.back(), release2.getId());
-	}
+        const auto releases{ Release::findIds(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::Name)) };
+        ASSERT_EQ(releases.results.size(), 2);
+        EXPECT_EQ(releases.results.front(), release1.getId());
+        EXPECT_EQ(releases.results.back(), release2.getId());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		const auto releases {Release::find(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::Random) )};
-		ASSERT_EQ(releases.results.size(), 2);
-	}
+        const auto releases{ Release::findIds(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::Random)) };
+        ASSERT_EQ(releases.results.size(), 2);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		const auto releases {Release::find(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::Date) )};
-		ASSERT_EQ(releases.results.size(), 2);
-		EXPECT_EQ(releases.results.front(), release2.getId());
-		EXPECT_EQ(releases.results.back(), release1.getId());
-	}
+        const auto releases{ Release::findIds(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::Date)) };
+        ASSERT_EQ(releases.results.size(), 2);
+        EXPECT_EQ(releases.results.front(), release2.getId());
+        EXPECT_EQ(releases.results.back(), release1.getId());
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		const auto releases {Release::find(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::OriginalDate) )};
-		ASSERT_EQ(releases.results.size(), 2);
-		EXPECT_EQ(releases.results.front(), release1.getId());
-		EXPECT_EQ(releases.results.back(), release2.getId());
-	}
-	{
-		auto transaction {session.createSharedTransaction()};
+        const auto releases{ Release::findIds(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::OriginalDate)) };
+        ASSERT_EQ(releases.results.size(), 2);
+        EXPECT_EQ(releases.results.front(), release1.getId());
+        EXPECT_EQ(releases.results.back(), release2.getId());
+    }
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		const auto releases {Release::find(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::OriginalDateDesc) )};
-		ASSERT_EQ(releases.results.size(), 2);
-		EXPECT_EQ(releases.results.front(), release2.getId());
-		EXPECT_EQ(releases.results.back(), release1.getId());
-	}
+        const auto releases{ Release::findIds(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::OriginalDateDesc)) };
+        ASSERT_EQ(releases.results.size(), 2);
+        EXPECT_EQ(releases.results.front(), release2.getId());
+        EXPECT_EQ(releases.results.back(), release1.getId());
+    }
 }
 
diff --git a/src/libs/services/database/test/StarredArtist.cpp b/src/libs/services/database/test/StarredArtist.cpp
index de2f5511..8be5df9b 100644
--- a/src/libs/services/database/test/StarredArtist.cpp
+++ b/src/libs/services/database/test/StarredArtist.cpp
@@ -26,102 +26,100 @@ using ScopedStarredArtist = ScopedEntity<Database::StarredArtist>;
 
 TEST_F(DatabaseFixture, StarredArtist)
 {
-	ScopedArtist artist {session, "MyArtist"};
-	ScopedUser user {session, "MyUser"};
-	ScopedUser user2 {session, "MyUser2"};
+    ScopedArtist artist{ session, "MyArtist" };
+    ScopedUser user{ session, "MyUser" };
+    ScopedUser user2{ session, "MyUser2" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto starredArtist {StarredArtist::find(session, artist->getId(), user->getId(), Scrobbler::Internal)};
-		EXPECT_FALSE(starredArtist);
-		EXPECT_EQ(StarredArtist::getCount(session), 0);
+        auto starredArtist{ StarredArtist::find(session, artist->getId(), user->getId(), FeedbackBackend::Internal) };
+        EXPECT_FALSE(starredArtist);
+        EXPECT_EQ(StarredArtist::getCount(session), 0);
 
-		auto artists {Artist::find(session, Artist::FindParameters {})};
-		EXPECT_EQ(artists.results.size(), 1);
-	}
+        auto artists{ Artist::findIds(session, Artist::FindParameters {}) };
+        EXPECT_EQ(artists.results.size(), 1);
+    }
 
-	ScopedStarredArtist starredArtist {session, artist.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
-	{
-		auto transaction {session.createSharedTransaction()};
+    ScopedStarredArtist starredArtist{ session, artist.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto gotArtist {StarredArtist::find(session, artist->getId(), user->getId(), Scrobbler::Internal)};
-		EXPECT_EQ(gotArtist->getId(), starredArtist->getId());
-		EXPECT_EQ(StarredArtist::getCount(session), 1);
-	}
+        auto gotArtist{ StarredArtist::find(session, artist->getId(), user->getId(), FeedbackBackend::Internal) };
+        EXPECT_EQ(gotArtist->getId(), starredArtist->getId());
+        EXPECT_EQ(StarredArtist::getCount(session), 1);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto artists {Artist::find(session, Artist::FindParameters {})};
-		EXPECT_EQ(artists.results.size(), 1);
+        auto artists{ Artist::findIds(session, Artist::FindParameters {}) };
+        EXPECT_EQ(artists.results.size(), 1);
 
-		artists = Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal));
-		EXPECT_EQ(artists.results.size(), 1);
+        artists = Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal));
+        EXPECT_EQ(artists.results.size(), 1);
 
-		artists = Artist::find(session, Artist::FindParameters {}.setStarringUser(user2.getId(), Scrobbler::Internal));
-		EXPECT_EQ(artists.results.size(), 0);
-	}
+        artists = Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user2.getId(), FeedbackBackend::Internal));
+        EXPECT_EQ(artists.results.size(), 0);
+    }
 }
 
 TEST_F(DatabaseFixture, StarredArtist_PendingDestroy)
 {
-	ScopedArtist artist {session, "MyArtist"};
-	ScopedUser user {session, "MyUser"};
-	ScopedStarredArtist starredArtist {session, artist.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
+    ScopedArtist artist{ session, "MyArtist" };
+    ScopedUser user{ session, "MyUser" };
+    ScopedStarredArtist starredArtist{ session, artist.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		auto artists {Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal))};
-		EXPECT_EQ(artists.results.size(), 1);
+        auto artists{ Artist::findIds(session, Artist::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal)) };
+        EXPECT_EQ(artists.results.size(), 1);
 
-		starredArtist.get().modify()->setScrobblingState(ScrobblingState::PendingRemove);
-		artists = Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal));
-		EXPECT_EQ(artists.results.size(), 0);
-	}
+        starredArtist.get().modify()->setSyncState(SyncState::PendingRemove);
+        artists = Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal));
+        EXPECT_EQ(artists.results.size(), 0);
+    }
 }
 
 TEST_F(DatabaseFixture, StarredArtist_dateTime)
 {
-	ScopedArtist artist1 {session, "MyArtist1"};
-	ScopedArtist artist2 {session, "MyArtist2"};
-	ScopedUser user {session, "MyUser"};
+    ScopedArtist artist1{ session, "MyArtist1" };
+    ScopedArtist artist2{ session, "MyArtist2" };
+    ScopedUser user{ session, "MyUser" };
 
-	ScopedStarredArtist starredArtist1 {session, artist1.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
-	ScopedStarredArtist starredArtist2 {session, artist2.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
+    ScopedStarredArtist starredArtist1{ session, artist1.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
+    ScopedStarredArtist starredArtist2{ session, artist2.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
 
-	const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 2}, Wt::WTime {12, 30, 1}};
+    const Wt::WDateTime dateTime{ Wt::WDate {1950, 1, 2}, Wt::WTime {12, 30, 1} };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto artists {Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal))};
-		EXPECT_EQ(artists.results.size(), 2);
-	}
+        auto artists{ Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal)) };
+        EXPECT_EQ(artists.results.size(), 2);
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		starredArtist1.get().modify()->setDateTime(dateTime);
-		starredArtist2.get().modify()->setDateTime(dateTime.addSecs(-1));
+        starredArtist1.get().modify()->setDateTime(dateTime);
+        starredArtist2.get().modify()->setDateTime(dateTime.addSecs(-1));
 
-		auto artists {Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal)
-																		.setSortMethod(ArtistSortMethod::StarredDateDesc))};
-		ASSERT_EQ(artists.results.size(), 2);
-		EXPECT_EQ(artists.results[0], starredArtist1->getArtist()->getId());
-		EXPECT_EQ(artists.results[1], starredArtist2->getArtist()->getId());
-	}
-	{
-		auto transaction {session.createUniqueTransaction()};
+        auto artists{ Artist::findIds(session, Artist::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ArtistSortMethod::StarredDateDesc)) };
+        ASSERT_EQ(artists.results.size(), 2);
+        EXPECT_EQ(artists.results[0], starredArtist1->getArtist()->getId());
+        EXPECT_EQ(artists.results[1], starredArtist2->getArtist()->getId());
+    }
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		starredArtist1.get().modify()->setDateTime(dateTime);
-		starredArtist2.get().modify()->setDateTime(dateTime.addSecs(1));
+        starredArtist1.get().modify()->setDateTime(dateTime);
+        starredArtist2.get().modify()->setDateTime(dateTime.addSecs(1));
 
-		auto artists {Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal)
-																		.setSortMethod(ArtistSortMethod::StarredDateDesc))};
-		ASSERT_EQ(artists.results.size(), 2);
-		EXPECT_EQ(artists.results[0], starredArtist2->getArtist()->getId());
-		EXPECT_EQ(artists.results[1], starredArtist1->getArtist()->getId());
-	}
+        auto artists{ Artist::findIds(session, Artist::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ArtistSortMethod::StarredDateDesc)) };
+        ASSERT_EQ(artists.results.size(), 2);
+        EXPECT_EQ(artists.results[0], starredArtist2->getArtist()->getId());
+        EXPECT_EQ(artists.results[1], starredArtist1->getArtist()->getId());
+    }
 }
diff --git a/src/libs/services/database/test/StarredRelease.cpp b/src/libs/services/database/test/StarredRelease.cpp
index b60b149f..e595a416 100644
--- a/src/libs/services/database/test/StarredRelease.cpp
+++ b/src/libs/services/database/test/StarredRelease.cpp
@@ -26,102 +26,100 @@ using ScopedStarredRelease = ScopedEntity<Database::StarredRelease>;
 
 TEST_F(DatabaseFixture, StarredRelease)
 {
-	ScopedRelease release {session, "MyRelease"};
-	ScopedUser user {session, "MyUser"};
-	ScopedUser user2 {session, "MyUser2"};
+    ScopedRelease release{ session, "MyRelease" };
+    ScopedUser user{ session, "MyUser" };
+    ScopedUser user2{ session, "MyUser2" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto starredRelease {StarredRelease::find(session, release->getId(), user->getId(), Scrobbler::Internal)};
-		EXPECT_FALSE(starredRelease);
-		EXPECT_EQ(StarredRelease::getCount(session), 0);
+        auto starredRelease{ StarredRelease::find(session, release->getId(), user->getId(), FeedbackBackend::Internal) };
+        EXPECT_FALSE(starredRelease);
+        EXPECT_EQ(StarredRelease::getCount(session), 0);
 
-		auto releases {Release::find(session, Release::FindParameters {})};
-		EXPECT_EQ(releases.results.size(), 1);
-	}
+        auto releases{ Release::find(session, Release::FindParameters {}) };
+        EXPECT_EQ(releases.results.size(), 1);
+    }
 
-	ScopedStarredRelease starredRelease {session, release.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
-	{
-		auto transaction {session.createSharedTransaction()};
+    ScopedStarredRelease starredRelease{ session, release.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto gotRelease {StarredRelease::find(session, release->getId(), user->getId(), Scrobbler::Internal)};
-		EXPECT_EQ(gotRelease->getId(), starredRelease->getId());
-		EXPECT_EQ(StarredRelease::getCount(session), 1);
-	}
+        auto gotRelease{ StarredRelease::find(session, release->getId(), user->getId(), FeedbackBackend::Internal) };
+        EXPECT_EQ(gotRelease->getId(), starredRelease->getId());
+        EXPECT_EQ(StarredRelease::getCount(session), 1);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto releases {Release::find(session, Release::FindParameters {})};
-		EXPECT_EQ(releases.results.size(), 1);
+        auto releases{ Release::find(session, Release::FindParameters {}) };
+        EXPECT_EQ(releases.results.size(), 1);
 
-		releases = Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal));
-		EXPECT_EQ(releases.results.size(), 1);
+        releases = Release::find(session, Release::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal));
+        EXPECT_EQ(releases.results.size(), 1);
 
-		releases = Release::find(session, Release::FindParameters {}.setStarringUser(user2.getId(), Scrobbler::Internal));
-		EXPECT_EQ(releases.results.size(), 0);
-	}
+        releases = Release::find(session, Release::FindParameters{}.setStarringUser(user2.getId(), FeedbackBackend::Internal));
+        EXPECT_EQ(releases.results.size(), 0);
+    }
 }
 
 TEST_F(DatabaseFixture, Starredrelease_PendingDestroy)
 {
-	ScopedRelease release {session, "MyRelease"};
-	ScopedUser user {session, "MyUser"};
-	ScopedStarredRelease starredRelease {session, release.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
+    ScopedRelease release{ session, "MyRelease" };
+    ScopedUser user{ session, "MyUser" };
+    ScopedStarredRelease starredRelease{ session, release.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		auto releases {Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal))};
-		EXPECT_EQ(releases.results.size(), 1);
+        auto releases{ Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal)) };
+        EXPECT_EQ(releases.results.size(), 1);
 
-		starredRelease.get().modify()->setScrobblingState(ScrobblingState::PendingRemove);
-		releases = Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal));
-		EXPECT_EQ(releases.results.size(), 0);
-	}
+        starredRelease.get().modify()->setSyncState(SyncState::PendingRemove);
+        releases = Release::find(session, Release::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal));
+        EXPECT_EQ(releases.results.size(), 0);
+    }
 }
 
 TEST_F(DatabaseFixture, StarredRelease_dateTime)
 {
-	ScopedRelease release1 {session, "MyRelease1"};
-	ScopedRelease release2 {session, "MyRelease2"};
-	ScopedUser user {session, "MyUser"};
+    ScopedRelease release1{ session, "MyRelease1" };
+    ScopedRelease release2{ session, "MyRelease2" };
+    ScopedUser user{ session, "MyUser" };
 
-	ScopedStarredRelease starredRelease1 {session, release1.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
-	ScopedStarredRelease starredRelease2 {session, release2.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
+    ScopedStarredRelease starredRelease1{ session, release1.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
+    ScopedStarredRelease starredRelease2{ session, release2.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
 
-	const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 2}, Wt::WTime {12, 30, 1}};
+    const Wt::WDateTime dateTime{ Wt::WDate {1950, 1, 2}, Wt::WTime {12, 30, 1} };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		auto releases {Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal))};
-		EXPECT_EQ(releases.results.size(), 2);
-	}
+        auto releases{ Release::findIds(session, Release::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal)) };
+        EXPECT_EQ(releases.results.size(), 2);
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		starredRelease1.get().modify()->setDateTime(dateTime);
-		starredRelease2.get().modify()->setDateTime(dateTime.addSecs(-1));
+        starredRelease1.get().modify()->setDateTime(dateTime);
+        starredRelease2.get().modify()->setDateTime(dateTime.addSecs(-1));
 
-		auto releases {Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal)
-																			.setSortMethod(ReleaseSortMethod::StarredDateDesc))};
-		ASSERT_EQ(releases.results.size(), 2);
-		EXPECT_EQ(releases.results[0], starredRelease1->getRelease()->getId());
-		EXPECT_EQ(releases.results[1], starredRelease2->getRelease()->getId());
-	}
-	{
-		auto transaction {session.createUniqueTransaction()};
+        auto releases{ Release::findIds(session, Release::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ReleaseSortMethod::StarredDateDesc)) };
+        ASSERT_EQ(releases.results.size(), 2);
+        EXPECT_EQ(releases.results[0], starredRelease1->getRelease()->getId());
+        EXPECT_EQ(releases.results[1], starredRelease2->getRelease()->getId());
+    }
+    {
+        auto transaction{ session.createUniqueTransaction() };
 
-		starredRelease1.get().modify()->setDateTime(dateTime);
-		starredRelease2.get().modify()->setDateTime(dateTime.addSecs(1));
+        starredRelease1.get().modify()->setDateTime(dateTime);
+        starredRelease2.get().modify()->setDateTime(dateTime.addSecs(1));
 
-		auto releases {Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal)
-																			.setSortMethod(ReleaseSortMethod::StarredDateDesc))};
-		ASSERT_EQ(releases.results.size(), 2);
-		EXPECT_EQ(releases.results[0], starredRelease2->getRelease()->getId());
-		EXPECT_EQ(releases.results[1], starredRelease1->getRelease()->getId());
-	}
+        auto releases{ Release::findIds(session, Release::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ReleaseSortMethod::StarredDateDesc)) };
+        ASSERT_EQ(releases.results.size(), 2);
+        EXPECT_EQ(releases.results[0], starredRelease2->getRelease()->getId());
+        EXPECT_EQ(releases.results[1], starredRelease1->getRelease()->getId());
+    }
 }
diff --git a/src/libs/services/database/test/StarredTrack.cpp b/src/libs/services/database/test/StarredTrack.cpp
index 36c3faac..a471215e 100644
--- a/src/libs/services/database/test/StarredTrack.cpp
+++ b/src/libs/services/database/test/StarredTrack.cpp
@@ -26,102 +26,100 @@ using ScopedStarredTrack = ScopedEntity<Database::StarredTrack>;
 
 TEST_F(DatabaseFixture, StarredTrack)
 {
-	ScopedTrack track {session, "MyTrack"};
-	ScopedUser user {session, "MyUser"};
-	ScopedUser user2 {session, "MyUser2"};
+    ScopedTrack track {session, "MyTrack"};
+    ScopedUser user {session, "MyUser"};
+    ScopedUser user2 {session, "MyUser2"};
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction {session.createSharedTransaction()};
 
-		auto starredTrack {StarredTrack::find(session, track->getId(), user->getId(), Scrobbler::Internal)};
-		EXPECT_FALSE(starredTrack);
-		EXPECT_EQ(StarredTrack::getCount(session), 0);
+        auto starredTrack {StarredTrack::find(session, track->getId(), user->getId(), FeedbackBackend::Internal)};
+        EXPECT_FALSE(starredTrack);
+        EXPECT_EQ(StarredTrack::getCount(session), 0);
 
-		auto tracks {Track::find(session, Track::FindParameters {})};
-		EXPECT_EQ(tracks.results.size(), 1);
-	}
+        auto tracks {Track::findIds(session, Track::FindParameters {})};
+        EXPECT_EQ(tracks.results.size(), 1);
+    }
 
-	ScopedStarredTrack starredTrack {session, track.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
-	{
-		auto transaction {session.createSharedTransaction()};
+    ScopedStarredTrack starredTrack {session, track.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal};
+    {
+        auto transaction {session.createSharedTransaction()};
 
-		auto gotTrack {StarredTrack::find(session, track->getId(), user->getId(), Scrobbler::Internal)};
-		EXPECT_EQ(gotTrack->getId(), starredTrack->getId());
-		EXPECT_EQ(StarredTrack::getCount(session), 1);
-	}
+        auto gotTrack {StarredTrack::find(session, track->getId(), user->getId(), FeedbackBackend::Internal)};
+        EXPECT_EQ(gotTrack->getId(), starredTrack->getId());
+        EXPECT_EQ(StarredTrack::getCount(session), 1);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction {session.createSharedTransaction()};
 
-		auto tracks {Track::find(session, Track::FindParameters {})};
-		EXPECT_EQ(tracks.results.size(), 1);
+        auto tracks {Track::findIds(session, Track::FindParameters {})};
+        EXPECT_EQ(tracks.results.size(), 1);
 
-		tracks = Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal));
-		EXPECT_EQ(tracks.results.size(), 1);
+        tracks = Track::findIds(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal));
+        EXPECT_EQ(tracks.results.size(), 1);
 
-		tracks = Track::find(session, Track::FindParameters {}.setStarringUser(user2.getId(), Scrobbler::Internal));
-		EXPECT_EQ(tracks.results.size(), 0);
-	}
+        tracks = Track::findIds(session, Track::FindParameters {}.setStarringUser(user2.getId(), FeedbackBackend::Internal));
+        EXPECT_EQ(tracks.results.size(), 0);
+    }
 }
 
 TEST_F(DatabaseFixture, Starredtrack_PendingDestroy)
 {
-	ScopedTrack track {session, "MyTrack"};
-	ScopedUser user {session, "MyUser"};
-	ScopedStarredTrack starredTrack {session, track.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
+    ScopedTrack track {session, "MyTrack"};
+    ScopedUser user {session, "MyUser"};
+    ScopedStarredTrack starredTrack {session, track.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal};
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction {session.createUniqueTransaction()};
 
-		auto tracks {Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal))};
-		EXPECT_EQ(tracks.results.size(), 1);
+        auto tracks {Track::findIds(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal))};
+        EXPECT_EQ(tracks.results.size(), 1);
 
-		starredTrack.get().modify()->setScrobblingState(ScrobblingState::PendingRemove);
-		tracks = Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal));
-		EXPECT_EQ(tracks.results.size(), 0);
-	}
+        starredTrack.get().modify()->setSyncState(SyncState::PendingRemove);
+        tracks = Track::findIds(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal));
+        EXPECT_EQ(tracks.results.size(), 0);
+    }
 }
 
 TEST_F(DatabaseFixture, StarredTrack_dateTime)
 {
-	ScopedTrack track1 {session, "MyTrack1"};
-	ScopedTrack track2 {session, "MyTrack2"};
-	ScopedUser user {session, "MyUser"};
+    ScopedTrack track1 {session, "MyTrack1"};
+    ScopedTrack track2 {session, "MyTrack2"};
+    ScopedUser user {session, "MyUser"};
 
-	ScopedStarredTrack starredTrack1 {session, track1.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
-	ScopedStarredTrack starredTrack2 {session, track2.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
+    ScopedStarredTrack starredTrack1 {session, track1.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal};
+    ScopedStarredTrack starredTrack2 {session, track2.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal};
 
-	const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 2}, Wt::WTime {12, 30, 1}};
+    const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 2}, Wt::WTime {12, 30, 1}};
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction {session.createSharedTransaction()};
 
-		auto tracks {Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal))};
-		EXPECT_EQ(tracks.results.size(), 2);
-	}
+        auto tracks {Track::findIds(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal))};
+        EXPECT_EQ(tracks.results.size(), 2);
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
+    {
+        auto transaction {session.createUniqueTransaction()};
 
-		starredTrack1.get().modify()->setDateTime(dateTime);
-		starredTrack2.get().modify()->setDateTime(dateTime.addSecs(-1));
+        starredTrack1.get().modify()->setDateTime(dateTime);
+        starredTrack2.get().modify()->setDateTime(dateTime.addSecs(-1));
 
-		auto tracks {Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal)
-																	.setSortMethod(TrackSortMethod::StarredDateDesc))};
-		ASSERT_EQ(tracks.results.size(), 2);
-		EXPECT_EQ(tracks.results[0], starredTrack1->getTrack()->getId());
-		EXPECT_EQ(tracks.results[1], starredTrack2->getTrack()->getId());
-	}
-	{
-		auto transaction {session.createUniqueTransaction()};
+        auto tracks {Track::findIds(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(TrackSortMethod::StarredDateDesc))};
+        ASSERT_EQ(tracks.results.size(), 2);
+        EXPECT_EQ(tracks.results[0], starredTrack1->getTrack()->getId());
+        EXPECT_EQ(tracks.results[1], starredTrack2->getTrack()->getId());
+    }
+    {
+        auto transaction {session.createUniqueTransaction()};
 
-		starredTrack1.get().modify()->setDateTime(dateTime);
-		starredTrack2.get().modify()->setDateTime(dateTime.addSecs(1));
+        starredTrack1.get().modify()->setDateTime(dateTime);
+        starredTrack2.get().modify()->setDateTime(dateTime.addSecs(1));
 
-		auto tracks {Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal)
-																	.setSortMethod(TrackSortMethod::StarredDateDesc))};
-		ASSERT_EQ(tracks.results.size(), 2);
-		EXPECT_EQ(tracks.results[0], starredTrack2->getTrack()->getId());
-		EXPECT_EQ(tracks.results[1], starredTrack1->getTrack()->getId());
-	}
+        auto tracks {Track::findIds(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(TrackSortMethod::StarredDateDesc))};
+        ASSERT_EQ(tracks.results.size(), 2);
+        EXPECT_EQ(tracks.results[0], starredTrack2->getTrack()->getId());
+        EXPECT_EQ(tracks.results[1], starredTrack1->getTrack()->getId());
+    }
 }
diff --git a/src/libs/services/database/test/Track.cpp b/src/libs/services/database/test/Track.cpp
index 3e959a70..0711edb6 100644
--- a/src/libs/services/database/test/Track.cpp
+++ b/src/libs/services/database/test/Track.cpp
@@ -25,137 +25,138 @@ using namespace Database;
 
 TEST_F(DatabaseFixture, Track)
 {
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_EQ(Track::find(session, Track::FindParameters {}).results.size(), 0);
-		EXPECT_EQ(Track::getCount(session), 0);
-		EXPECT_FALSE(Track::exists(session, 0));
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_EQ(Track::find(session, Track::FindParameters{}).results.size(), 0);
+        EXPECT_EQ(Track::findIds(session, Track::FindParameters{}).results.size(), 0);
+        EXPECT_EQ(Track::getCount(session), 0);
+        EXPECT_FALSE(Track::exists(session, 0));
+    }
 
-	ScopedTrack track {session, "MyTrackFile"};
+    ScopedTrack track{ session, "MyTrackFile" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		EXPECT_EQ(Track::find(session, Track::FindParameters {}).results.size(), 1);
-		EXPECT_EQ(Track::getCount(session), 1);
-		EXPECT_TRUE(Track::exists(session, track.getId()));
-		auto myTrack {Track::find(session, track.getId())};
-		ASSERT_TRUE(myTrack);
-		EXPECT_EQ(myTrack->getId(), track.getId());
-	}
+        EXPECT_EQ(Track::find(session, Track::FindParameters{}).results.size(), 1);
+        EXPECT_EQ(Track::getCount(session), 1);
+        EXPECT_TRUE(Track::exists(session, track.getId()));
+        auto myTrack{ Track::find(session, track.getId()) };
+        ASSERT_TRUE(myTrack);
+        EXPECT_EQ(myTrack->getId(), track.getId());
+    }
 }
 
 TEST_F(DatabaseFixture, MultipleTracks)
 {
-	ScopedTrack track1 {session, "MyTrackFile1"};
-	ScopedTrack track2 {session, "MyTrackFile2"};
+    ScopedTrack track1{ session, "MyTrackFile1" };
+    ScopedTrack track2{ session, "MyTrackFile2" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		EXPECT_TRUE(track1.getId() != track2.getId());
-		EXPECT_TRUE(track1.get() != track2.get());
-		EXPECT_FALSE(track1.get() == track2.get());
-	}
+        EXPECT_TRUE(track1.getId() != track2.getId());
+        EXPECT_TRUE(track1.get() != track2.get());
+        EXPECT_FALSE(track1.get() == track2.get());
+    }
 }
 
 TEST_F(DatabaseFixture, MultipleTracksSearchByFilter)
 {
-	ScopedTrack track1 {session, ""};
-	ScopedTrack track2 {session, ""};
-	ScopedTrack track3 {session, ""};
-	ScopedTrack track4 {session, ""};
-	ScopedTrack track5 {session, ""};
-	ScopedTrack track6 {session, ""};
+    ScopedTrack track1{ session, "" };
+    ScopedTrack track2{ session, "" };
+    ScopedTrack track3{ session, "" };
+    ScopedTrack track4{ session, "" };
+    ScopedTrack track5{ session, "" };
+    ScopedTrack track6{ session, "" };
 
-	{
-		auto transaction {session.createUniqueTransaction()};
-		track1.get().modify()->setName("MyTrack");
-		track2.get().modify()->setName("MyTrack%");
-		track3.get().modify()->setName("MyTrack%Foo");
-		track4.get().modify()->setName("%MyTrack");
-		track5.get().modify()->setName("Foo%MyTrack");
-		track6.get().modify()->setName("M_Track");
-	}
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        track1.get().modify()->setName("MyTrack");
+        track2.get().modify()->setName("MyTrack%");
+        track3.get().modify()->setName("MyTrack%Foo");
+        track4.get().modify()->setName("%MyTrack");
+        track5.get().modify()->setName("Foo%MyTrack");
+        track6.get().modify()->setName("M_Track");
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		{
-			const auto tracks {Track::find(session, Track::FindParameters {}.setKeywords({"Track"}))};
-			EXPECT_EQ(tracks.results.size(), 6);
-		}
-		{
-			const auto tracks {Track::find(session, Track::FindParameters {}.setKeywords({"MyTrack"}))};
-			EXPECT_EQ(tracks.results.size(), 5);
-			EXPECT_TRUE(std::none_of(std::cbegin(tracks.results), std::cend(tracks.results), [&](const TrackId trackId) { return trackId == track6.getId(); }));
-		}
-		{
-			const auto tracks {Track::find(session, Track::FindParameters {}.setKeywords({"MyTrack%"}))};
-			ASSERT_EQ(tracks.results.size(), 2);
-			EXPECT_EQ(tracks.results[0], track2.getId());
-			EXPECT_EQ(tracks.results[1], track3.getId());
-		}
-		{
-			const auto tracks {Track::find(session, Track::FindParameters {}.setKeywords({"%MyTrack"}))};
-			ASSERT_EQ(tracks.results.size(), 2);
-			EXPECT_EQ(tracks.results[0], track4.getId());
-			EXPECT_EQ(tracks.results[1], track5.getId());
-		}
-	}
+        {
+            const auto tracks{ Track::findIds(session, Track::FindParameters {}.setKeywords({"Track"})) };
+            EXPECT_EQ(tracks.results.size(), 6);
+        }
+        {
+            const auto tracks{ Track::findIds(session, Track::FindParameters {}.setKeywords({"MyTrack"})) };
+            EXPECT_EQ(tracks.results.size(), 5);
+            EXPECT_TRUE(std::none_of(std::cbegin(tracks.results), std::cend(tracks.results), [&](const TrackId trackId) { return trackId == track6.getId(); }));
+        }
+        {
+            const auto tracks{ Track::findIds(session, Track::FindParameters {}.setKeywords({"MyTrack%"})) };
+            ASSERT_EQ(tracks.results.size(), 2);
+            EXPECT_EQ(tracks.results[0], track2.getId());
+            EXPECT_EQ(tracks.results[1], track3.getId());
+        }
+        {
+            const auto tracks{ Track::findIds(session, Track::FindParameters {}.setKeywords({"%MyTrack"})) };
+            ASSERT_EQ(tracks.results.size(), 2);
+            EXPECT_EQ(tracks.results[0], track4.getId());
+            EXPECT_EQ(tracks.results[1], track5.getId());
+        }
+    }
 }
 
 TEST_F(DatabaseFixture, Track_date)
 {
-	ScopedTrack track {session, "MyTrack"};
+    ScopedTrack track{ session, "MyTrack" };
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_EQ(track->getYear(), std::nullopt);
-		EXPECT_EQ(track->getOriginalYear(), std::nullopt);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_EQ(track->getYear(), std::nullopt);
+        EXPECT_EQ(track->getOriginalYear(), std::nullopt);
+    }
 
-	{
-		auto transaction {session.createUniqueTransaction()};
-		track.get().modify()->setDate(Wt::WDate {1995, 5, 5});
-		track.get().modify()->setOriginalDate(Wt::WDate {1994, 2, 2});
-	}
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        track.get().modify()->setDate(Wt::WDate{ 1995, 5, 5 });
+        track.get().modify()->setOriginalDate(Wt::WDate{ 1994, 2, 2 });
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		EXPECT_EQ(track->getYear(), 1995);
-		EXPECT_EQ(track->getOriginalYear(), 1994);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        EXPECT_EQ(track->getYear(), 1995);
+        EXPECT_EQ(track->getOriginalYear(), 1994);
+    }
 }
 
 TEST_F(DatabaseFixture, Track_writtenAfter)
 {
-	ScopedTrack track {session, "MyTrack"};
+    ScopedTrack track{ session, "MyTrack" };
 
-	const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 1}, Wt::WTime {12, 30, 20}};
+    const Wt::WDateTime dateTime{ Wt::WDate {1950, 1, 1}, Wt::WTime {12, 30, 20} };
 
-	{
-		auto transaction {session.createUniqueTransaction()};
-		track.get().modify()->setLastWriteTime(dateTime);
-	}
+    {
+        auto transaction{ session.createUniqueTransaction() };
+        track.get().modify()->setLastWriteTime(dateTime);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		const auto tracks {Track::find(session, Track::FindParameters {})};
-		EXPECT_EQ(tracks.results.size(), 1);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        const auto tracks{ Track::findIds(session, Track::FindParameters {}) };
+        EXPECT_EQ(tracks.results.size(), 1);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		const auto tracks {Track::find(session, Track::FindParameters {}.setWrittenAfter(dateTime.addSecs(-1)))};
-		EXPECT_EQ(tracks.results.size(), 1);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        const auto tracks{ Track::findIds(session, Track::FindParameters {}.setWrittenAfter(dateTime.addSecs(-1))) };
+        EXPECT_EQ(tracks.results.size(), 1);
+    }
 
-	{
-		auto transaction {session.createSharedTransaction()};
-		const auto tracks {Track::find(session, Track::FindParameters {}.setWrittenAfter(dateTime.addSecs(+1)))};
-		EXPECT_EQ(tracks.results.size(), 0);
-	}
+    {
+        auto transaction{ session.createSharedTransaction() };
+        const auto tracks{ Track::findIds(session, Track::FindParameters {}.setWrittenAfter(dateTime.addSecs(+1))) };
+        EXPECT_EQ(tracks.results.size(), 0);
+    }
 }
 
diff --git a/src/libs/services/database/test/TrackList.cpp b/src/libs/services/database/test/TrackList.cpp
index cb2db0c9..f05cb48a 100644
--- a/src/libs/services/database/test/TrackList.cpp
+++ b/src/libs/services/database/test/TrackList.cpp
@@ -49,10 +49,10 @@ TEST_F(DatabaseFixture, SingleTrackListSingleTrack)
 	{
 		auto transaction {session.createSharedTransaction()};
 
-		auto tracks {Track::find(session, Track::FindParameters {}.setTrackList(trackList1.getId()))};
+		auto tracks {Track::findIds(session, Track::FindParameters {}.setTrackList(trackList1.getId()))};
 		EXPECT_EQ(tracks.results.size(), 0);
 
-		tracks = Track::find(session, Track::FindParameters {}.setTrackList(trackList2.getId()));
+		tracks = Track::findIds(session, Track::FindParameters {}.setTrackList(trackList2.getId()));
 		EXPECT_EQ(tracks.results.size(), 0);
 	}
 
@@ -65,11 +65,11 @@ TEST_F(DatabaseFixture, SingleTrackListSingleTrack)
 	{
 		auto transaction {session.createSharedTransaction()};
 
-		auto tracks {Track::find(session, Track::FindParameters {}.setTrackList(trackList1.getId()))};
+		auto tracks {Track::findIds(session, Track::FindParameters {}.setTrackList(trackList1.getId()))};
 		ASSERT_EQ(tracks.results.size(), 1);
 		EXPECT_EQ(tracks.results.front(), track.getId());
 
-		tracks = Track::find(session, Track::FindParameters {}.setTrackList(trackList2.getId()));
+		tracks = Track::findIds(session, Track::FindParameters {}.setTrackList(trackList2.getId()));
 		EXPECT_EQ(tracks.results.size(), 0);
 	}
 }
diff --git a/src/libs/services/feedback/CMakeLists.txt b/src/libs/services/feedback/CMakeLists.txt
new file mode 100644
index 00000000..02e63624
--- /dev/null
+++ b/src/libs/services/feedback/CMakeLists.txt
@@ -0,0 +1,29 @@
+
+add_library(lmsfeedback SHARED
+	impl/internal/InternalBackend.cpp
+	impl/listenbrainz/FeedbacksParser.cpp
+	impl/listenbrainz/FeedbacksSynchronizer.cpp
+	impl/listenbrainz/FeedbackTypes.cpp
+	impl/listenbrainz/ListenBrainzBackend.cpp
+	impl/listenbrainz/Utils.cpp
+	impl/FeedbackService.cpp
+	)
+
+target_include_directories(lmsfeedback INTERFACE
+	include
+	)
+
+target_include_directories(lmsfeedback PRIVATE
+	include
+	impl
+	)
+
+target_link_libraries(lmsfeedback PRIVATE
+	lmsutils
+	)
+
+target_link_libraries(lmsfeedback PUBLIC
+	lmsdatabase
+	)
+
+install(TARGETS lmsfeedback DESTINATION lib)
diff --git a/src/libs/services/feedback/impl/FeedbackService.cpp b/src/libs/services/feedback/impl/FeedbackService.cpp
new file mode 100644
index 00000000..2a9a60a9
--- /dev/null
+++ b/src/libs/services/feedback/impl/FeedbackService.cpp
@@ -0,0 +1,185 @@
+/*
+ * Copyright (C) 2021 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "FeedbackService.hpp"
+#include "FeedbackService.impl.hpp"
+
+#include "services/database/Artist.hpp"
+#include "services/database/Db.hpp"
+#include "services/database/Release.hpp"
+#include "services/database/Session.hpp"
+#include "services/database/StarredArtist.hpp"
+#include "services/database/StarredRelease.hpp"
+#include "services/database/StarredTrack.hpp"
+#include "services/database/Track.hpp"
+#include "services/database/User.hpp"
+#include "utils/Logger.hpp"
+
+#include "internal/InternalBackend.hpp"
+#include "listenbrainz/ListenBrainzBackend.hpp"
+
+namespace Feedback
+{
+    std::unique_ptr<IFeedbackService> createFeedbackService(boost::asio::io_context& ioContext, Db& db)
+    {
+        return std::make_unique<FeedbackService>(ioContext, db);
+    }
+
+    FeedbackService::FeedbackService(boost::asio::io_context& ioContext, Db& db)
+        : _db{ db }
+    {
+        LMS_LOG(SCROBBLING, INFO) << "Starting service...";
+        _backends.emplace(Database::FeedbackBackend::Internal, std::make_unique<InternalBackend>(_db));
+        _backends.emplace(Database::FeedbackBackend::ListenBrainz, std::make_unique<ListenBrainz::ListenBrainzBackend>(ioContext, _db));
+        LMS_LOG(SCROBBLING, INFO) << "Service started!";
+    }
+
+    FeedbackService::~FeedbackService()
+    {
+        LMS_LOG(SCROBBLING, INFO) << "Service stopped!";
+    }
+
+    std::optional<Database::FeedbackBackend> FeedbackService::getUserFeedbackBackend(UserId userId)
+    {
+        std::optional<Database::FeedbackBackend> feedbackBackend;
+
+        Session& session{ _db.getTLSSession() };
+        auto transaction{ session.createSharedTransaction() };
+        if (const User::pointer user{ User::find(session, userId) })
+            feedbackBackend = user->getFeedbackBackend();
+
+        return feedbackBackend;
+    }
+
+    void FeedbackService::star(UserId userId, ArtistId artistId)
+    {
+        star<Artist, ArtistId, StarredArtist>(userId, artistId);
+    }
+
+    void FeedbackService::unstar(UserId userId, ArtistId artistId)
+    {
+        unstar<Artist, ArtistId, StarredArtist>(userId, artistId);
+    }
+
+    bool FeedbackService::isStarred(UserId userId, ArtistId artistId)
+    {
+        return isStarred<Artist, ArtistId, StarredArtist>(userId, artistId);
+    }
+
+    Wt::WDateTime FeedbackService::getStarredDateTime(UserId userId, ArtistId artistId)
+    {
+        return getStarredDateTime<Artist, ArtistId, StarredArtist>(userId, artistId);
+    }
+
+    FeedbackService::ArtistContainer FeedbackService::getStarredArtists(UserId userId, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, ArtistSortMethod sortMethod, Range range)
+    {
+        auto backend{ getUserFeedbackBackend(userId) };
+        if (!backend)
+            return {};
+
+        Artist::FindParameters params;
+        params.setStarringUser(userId, *backend);
+        params.setClusters(clusterIds);
+        params.setLinkType(linkType);
+        params.setSortMethod(sortMethod);
+        params.setRange(range);
+
+        Session& session{ _db.getTLSSession() };
+        auto transaction{ session.createSharedTransaction() };
+
+        return Artist::findIds(session, params);
+    }
+
+    void FeedbackService::star(UserId userId, ReleaseId releaseId)
+    {
+        star<Release, ReleaseId, StarredRelease>(userId, releaseId);
+    }
+
+    void FeedbackService::unstar(UserId userId, ReleaseId releaseId)
+    {
+        unstar<Release, ReleaseId, StarredRelease>(userId, releaseId);
+    }
+
+    bool FeedbackService::isStarred(UserId userId, ReleaseId releaseId)
+    {
+        return isStarred<Release, ReleaseId, StarredRelease>(userId, releaseId);
+    }
+
+    Wt::WDateTime FeedbackService::getStarredDateTime(UserId userId, ReleaseId releaseId)
+    {
+        return getStarredDateTime<Release, ReleaseId, StarredRelease>(userId, releaseId);
+    }
+
+    FeedbackService::ReleaseContainer FeedbackService::getStarredReleases(UserId userId, const std::vector<ClusterId>& clusterIds, Range range)
+    {
+        auto backend{ getUserFeedbackBackend(userId) };
+        if (!backend)
+            return {};
+
+        Release::FindParameters params;
+        params.setStarringUser(userId, *backend);
+        params.setClusters(clusterIds);
+        params.setSortMethod(ReleaseSortMethod::StarredDateDesc);
+        params.setRange(range);
+
+        Session& session{ _db.getTLSSession() };
+        auto transaction{ session.createSharedTransaction() };
+
+        return Release::findIds(session, params);
+    }
+
+    void FeedbackService::star(UserId userId, TrackId trackId)
+    {
+        star<Track, TrackId, StarredTrack>(userId, trackId);
+    }
+
+    void FeedbackService::unstar(UserId userId, TrackId trackId)
+    {
+        unstar<Track, TrackId, StarredTrack>(userId, trackId);
+    }
+
+    bool FeedbackService::isStarred(UserId userId, TrackId trackId)
+    {
+        return isStarred<Track, TrackId, StarredTrack>(userId, trackId);
+    }
+
+    Wt::WDateTime FeedbackService::getStarredDateTime(UserId userId, TrackId trackId)
+    {
+        return getStarredDateTime<Track, TrackId, StarredTrack>(userId, trackId);
+    }
+
+    FeedbackService::TrackContainer FeedbackService::getStarredTracks(UserId userId, const std::vector<ClusterId>& clusterIds, Range range)
+    {
+        auto backend{ getUserFeedbackBackend(userId) };
+        if (!backend)
+            return {};
+
+        Track::FindParameters params;
+        params.setStarringUser(userId, *backend);
+        params.setClusters(clusterIds);
+        params.setSortMethod(TrackSortMethod::StarredDateDesc);
+        params.setRange(range);
+
+        Session& session{ _db.getTLSSession() };
+        auto transaction{ session.createSharedTransaction() };
+
+        return Track::findIds(session, params);
+    }
+} // ns Feedback
+
diff --git a/src/libs/services/feedback/impl/FeedbackService.hpp b/src/libs/services/feedback/impl/FeedbackService.hpp
new file mode 100644
index 00000000..279a8fa7
--- /dev/null
+++ b/src/libs/services/feedback/impl/FeedbackService.hpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2021 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+
+#include "services/feedback/IFeedbackService.hpp"
+#include "IFeedbackBackend.hpp"
+
+namespace Database
+{
+    class Db;
+}
+
+namespace Feedback
+{
+    class FeedbackService : public IFeedbackService
+    {
+    public:
+        FeedbackService(boost::asio::io_context& ioContext, Database::Db& db);
+        ~FeedbackService();
+
+    private:
+        FeedbackService(const FeedbackService&) = delete;
+        FeedbackService& operator=(const FeedbackService&) = delete;
+
+        void star(Database::UserId userId, Database::ArtistId artistId) override;
+        void unstar(Database::UserId userId, Database::ArtistId artistId) override;
+        bool isStarred(Database::UserId userId, Database::ArtistId artistId) override;
+        Wt::WDateTime getStarredDateTime(Database::UserId userId, Database::ArtistId artistId) override;
+        ArtistContainer	getStarredArtists(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, std::optional<Database::TrackArtistLinkType> linkType, Database::ArtistSortMethod sortMethod, Database::Range range) override;
+
+        void star(Database::UserId userId, Database::ReleaseId releaseId) override;
+        void unstar(Database::UserId userId, Database::ReleaseId releaseId) override;
+        bool isStarred(Database::UserId userId, Database::ReleaseId releasedId) override;
+        Wt::WDateTime getStarredDateTime(Database::UserId userId, Database::ReleaseId releasedId) override;
+        ReleaseContainer getStarredReleases(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) override;
+
+        void star(Database::UserId userId, Database::TrackId trackId) override;
+        void unstar(Database::UserId userId, Database::TrackId trackId) override;
+        bool isStarred(Database::UserId userId, Database::TrackId trackId) override;
+        Wt::WDateTime getStarredDateTime(Database::UserId userId, Database::TrackId trackId) override;
+        TrackContainer getStarredTracks(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) override;
+
+        std::optional<Database::FeedbackBackend> getUserFeedbackBackend(Database::UserId userId);
+
+        template <typename ObjType, typename ObjIdType, typename StarredObjType>
+        void star(Database::UserId userId, ObjIdType id);
+        template <typename ObjType, typename ObjIdType, typename StarredObjType>
+        void unstar(Database::UserId userId, ObjIdType id);
+        template <typename ObjType, typename ObjIdType, typename StarredObjType>
+        bool isStarred(Database::UserId userId, ObjIdType id);
+        template <typename ObjType, typename ObjIdType, typename StarredObjType>
+        Wt::WDateTime getStarredDateTime(Database::UserId userId, ObjIdType id);
+
+        Database::Db& _db;
+        std::unordered_map<Database::FeedbackBackend, std::unique_ptr<IFeedbackBackend>> _backends;
+    };
+
+} // ns Feedback
diff --git a/src/libs/services/feedback/impl/FeedbackService.impl.hpp b/src/libs/services/feedback/impl/FeedbackService.impl.hpp
new file mode 100644
index 00000000..f16be52c
--- /dev/null
+++ b/src/libs/services/feedback/impl/FeedbackService.impl.hpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2021 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "services/database/Db.hpp"
+#include "services/database/Session.hpp"
+#include "services/database/User.hpp"
+
+namespace Feedback
+{
+    using namespace Database;
+
+    template <typename ObjType, typename ObjIdType, typename StarredObjType>
+    void FeedbackService::star(UserId userId, ObjIdType objId)
+    {
+        const auto backend{ getUserFeedbackBackend(userId) };
+        if (!backend)
+            return;
+
+        typename StarredObjType::IdType starredObjId;
+        {
+            Session& session{ _db.getTLSSession() };
+            auto transaction{ session.createUniqueTransaction() };
+
+            typename StarredObjType::pointer starredObj{ StarredObjType::find(session, objId, userId, *backend) };
+            if (!starredObj)
+            {
+                const typename ObjType::pointer obj{ ObjType::find(session, objId) };
+                if (!obj)
+                    return;
+
+                const User::pointer user{ User::find(session, userId) };
+                if (!user)
+                    return;
+
+                starredObj = session.create<StarredObjType>(obj, user, *backend);
+            }
+            starredObj.modify()->setDateTime(Wt::WDateTime::currentDateTime());
+            starredObjId = starredObj->getId();
+        }
+        _backends[*backend]->onStarred(starredObjId);
+    }
+
+    template <typename ObjType, typename ObjIdType, typename StarredObjType>
+    void FeedbackService::unstar(UserId userId, ObjIdType objId)
+    {
+        const auto backend{ getUserFeedbackBackend(userId) };
+        if (!backend)
+            return;
+
+        typename StarredObjType::IdType starredObjId;
+        {
+            Session& session{ _db.getTLSSession() };
+            auto transaction{ session.createSharedTransaction() };
+
+            typename StarredObjType::pointer starredObj{ StarredObjType::find(session, objId, userId, *backend) };
+            if (!starredObj)
+                return;
+
+            starredObjId = starredObj->getId();
+        }
+        _backends[*backend]->onUnstarred(starredObjId);
+    }
+
+    template <typename ObjType, typename ObjIdType, typename StarredObjType>
+    bool FeedbackService::isStarred(UserId userId, ObjIdType objId)
+    {
+        const auto backend{ getUserFeedbackBackend(userId) };
+        if (!backend)
+            return false;
+
+        Session& session{ _db.getTLSSession() };
+        auto transaction{ session.createSharedTransaction() };
+
+        typename StarredObjType::pointer starredObj{ StarredObjType::find(session, objId, userId, *backend) };
+        return starredObj && (starredObj->getSyncState() != SyncState::PendingRemove);
+    }
+
+    template <typename ObjType, typename ObjIdType, typename StarredObjType>
+    Wt::WDateTime FeedbackService::getStarredDateTime(UserId userId, ObjIdType objId)
+    {
+        const auto backend{ getUserFeedbackBackend(userId) };
+        if (!backend)
+            return {};
+
+        Session& session{ _db.getTLSSession() };
+        auto transaction{ session.createSharedTransaction() };
+
+        typename StarredObjType::pointer starredObj{ StarredObjType::find(session, objId, userId, *backend) };
+        if (starredObj && (starredObj->getSyncState() != SyncState::PendingRemove))
+            return starredObj->getDateTime();
+
+        return {};
+    }
+
+} // ns Feedback
\ No newline at end of file
diff --git a/src/libs/services/scrobbling/impl/IScrobbler.hpp b/src/libs/services/feedback/impl/IFeedbackBackend.hpp
similarity index 64%
rename from src/libs/services/scrobbling/impl/IScrobbler.hpp
rename to src/libs/services/feedback/impl/IFeedbackBackend.hpp
index e98ea1b7..1fe5ab24 100644
--- a/src/libs/services/scrobbling/impl/IScrobbler.hpp
+++ b/src/libs/services/feedback/impl/IFeedbackBackend.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 Emeric Poupon
+ * Copyright (C) 2023 Emeric Poupon
  *
  * This file is part of LMS.
  *
@@ -19,35 +19,17 @@
 
 #pragma once
 
-#include <chrono>
-#include <memory>
-#include <optional>
-
 #include "services/database/StarredArtistId.hpp"
 #include "services/database/StarredReleaseId.hpp"
 #include "services/database/StarredTrackId.hpp"
-#include "services/scrobbling/Listen.hpp"
 
-namespace Database
+namespace Feedback
 {
-    class Session;
-    class TrackList;
-    class User;
-}
-
-namespace Scrobbling
-{
-    class IScrobbler
+    class IFeedbackBackend
     {
     public:
-        virtual ~IScrobbler() = default;
+        virtual ~IFeedbackBackend() = default;
 
-        // Listens
-        virtual void listenStarted(const Listen& listen) = 0;
-        virtual void listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration) = 0;
-        virtual void addTimedListen(const TimedListen& listen) = 0;
-
-        // Feedbacks
         virtual void onStarred(Database::StarredArtistId) = 0;
         virtual void onUnstarred(Database::StarredArtistId) = 0;
         virtual void onStarred(Database::StarredReleaseId) = 0;
@@ -56,7 +38,6 @@ namespace Scrobbling
         virtual void onUnstarred(Database::StarredTrackId) = 0;
     };
 
-    std::unique_ptr<IScrobbler> createScrobbler(std::string_view backendName);
-
-} // ns Scrobbling
+    std::unique_ptr<IFeedbackBackend> createFeedbackBackend(std::string_view backendName);
 
+} // ns Feedback
diff --git a/src/libs/services/feedback/impl/internal/InternalBackend.cpp b/src/libs/services/feedback/impl/internal/InternalBackend.cpp
new file mode 100644
index 00000000..e73e3d1f
--- /dev/null
+++ b/src/libs/services/feedback/impl/internal/InternalBackend.cpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2021 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "InternalBackend.hpp"
+
+#include "services/database/Db.hpp"
+#include "services/database/Session.hpp"
+#include "services/database/StarredArtist.hpp"
+#include "services/database/StarredRelease.hpp"
+#include "services/database/StarredTrack.hpp"
+
+namespace Feedback
+{
+    namespace details
+    {
+        template <typename StarredObjType>
+        void onStarred(Database::Session& session, typename StarredObjType::IdType id)
+        {
+            auto transaction{ session.createUniqueTransaction() };
+
+            if (auto starredObj{ StarredObjType::find(session, id) })
+                starredObj.modify()->setSyncState(Database::SyncState::Synchronized);
+        }
+
+        template <typename StarredObjType>
+        void onUnstarred(Database::Session& session, typename StarredObjType::IdType id)
+        {
+            auto transaction{ session.createUniqueTransaction() };
+
+            if (auto starredObj{ StarredObjType::find(session, id) })
+                starredObj.remove();
+        }
+    }
+
+    InternalBackend::InternalBackend(Database::Db& db)
+        : _db{ db }
+    {}
+
+    void InternalBackend::onStarred(Database::StarredArtistId starredArtistId)
+    {
+        details::onStarred<Database::StarredArtist>(_db.getTLSSession(), starredArtistId);
+    }
+
+    void InternalBackend::onUnstarred(Database::StarredArtistId starredArtistId)
+    {
+        details::onUnstarred<Database::StarredArtist>(_db.getTLSSession(), starredArtistId);
+    }
+
+    void InternalBackend::onStarred(Database::StarredReleaseId starredReleaseId)
+    {
+        details::onStarred<Database::StarredRelease>(_db.getTLSSession(), starredReleaseId);
+    }
+
+    void InternalBackend::onUnstarred(Database::StarredReleaseId starredReleaseId)
+    {
+        details::onUnstarred<Database::StarredRelease>(_db.getTLSSession(), starredReleaseId);
+    }
+
+    void InternalBackend::onStarred(Database::StarredTrackId starredTrackId)
+    {
+        details::onStarred<Database::StarredTrack>(_db.getTLSSession(), starredTrackId);
+    }
+
+    void InternalBackend::onUnstarred(Database::StarredTrackId starredTrackId)
+    {
+        details::onUnstarred<Database::StarredTrack>(_db.getTLSSession(), starredTrackId);
+    }
+} // Feedback
diff --git a/src/libs/services/scrobbling/impl/internal/InternalScrobbler.hpp b/src/libs/services/feedback/impl/internal/InternalBackend.hpp
similarity index 74%
rename from src/libs/services/scrobbling/impl/internal/InternalScrobbler.hpp
rename to src/libs/services/feedback/impl/internal/InternalBackend.hpp
index ce3fb608..2b5bca01 100644
--- a/src/libs/services/scrobbling/impl/internal/InternalScrobbler.hpp
+++ b/src/libs/services/feedback/impl/internal/InternalBackend.hpp
@@ -19,26 +19,21 @@
 
 #pragma once
 
-#include "IScrobbler.hpp"
+#include "IFeedbackBackend.hpp"
 
 namespace Database
 {
     class Db;
 }
 
-namespace Scrobbling
+namespace Feedback
 {
-    class InternalScrobbler final : public IScrobbler
+    class InternalBackend final : public IFeedbackBackend
     {
     public:
-        InternalScrobbler(Database::Db& db);
+        InternalBackend(Database::Db& db);
 
     private:
-        // IScrobbler
-        void listenStarted(const Listen& listen) override;
-        void listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration) override;
-        void addTimedListen(const TimedListen& listen) override;
-
         void onStarred(Database::StarredArtistId) override;
         void onUnstarred(Database::StarredArtistId) override;
         void onStarred(Database::StarredReleaseId) override;
@@ -48,5 +43,5 @@ namespace Scrobbling
 
         Database::Db& _db;
     };
-} // Scrobbling
+} // Feedback
 
diff --git a/src/libs/services/feedback/impl/listenbrainz/Exception.hpp b/src/libs/services/feedback/impl/listenbrainz/Exception.hpp
new file mode 100644
index 00000000..45664f92
--- /dev/null
+++ b/src/libs/services/feedback/impl/listenbrainz/Exception.hpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2022 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "services/feedback/Exception.hpp"
+
+namespace Feedback::ListenBrainz
+{
+	class Exception : public ::Feedback::Exception
+	{
+		public:
+			using ::Feedback::Exception::Exception;
+	};
+}
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/FeedbackTypes.cpp b/src/libs/services/feedback/impl/listenbrainz/FeedbackTypes.cpp
similarity index 93%
rename from src/libs/services/scrobbling/impl/listenbrainz/FeedbackTypes.cpp
rename to src/libs/services/feedback/impl/listenbrainz/FeedbackTypes.cpp
index 0b4d5168..79c2f531 100644
--- a/src/libs/services/scrobbling/impl/listenbrainz/FeedbackTypes.cpp
+++ b/src/libs/services/feedback/impl/listenbrainz/FeedbackTypes.cpp
@@ -19,7 +19,7 @@
 
 #include "FeedbackTypes.hpp"
 
-namespace Scrobbling::ListenBrainz
+namespace Feedback::ListenBrainz
 {
 	std::ostream&
 	operator<<(std::ostream& os, const Feedback& feedback)
@@ -27,4 +27,4 @@ namespace Scrobbling::ListenBrainz
 		os << "created = '" << feedback.created.toString() << "', recording MBID = '" << feedback.recordingMBID.getAsString() << "', score = " << static_cast<int>(feedback.score);
 		return os;
 	}
-} // Scrobbling::ListenBrainz
+} // Feedback::ListenBrainz
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/FeedbackTypes.hpp b/src/libs/services/feedback/impl/listenbrainz/FeedbackTypes.hpp
similarity index 94%
rename from src/libs/services/scrobbling/impl/listenbrainz/FeedbackTypes.hpp
rename to src/libs/services/feedback/impl/listenbrainz/FeedbackTypes.hpp
index cb45d992..ec05760d 100644
--- a/src/libs/services/scrobbling/impl/listenbrainz/FeedbackTypes.hpp
+++ b/src/libs/services/feedback/impl/listenbrainz/FeedbackTypes.hpp
@@ -23,7 +23,7 @@
 #include <Wt/WDateTime.h>
 #include "utils/UUID.hpp"
 
-namespace Scrobbling::ListenBrainz
+namespace Feedback::ListenBrainz
 {
 	// See https://listenbrainz.readthedocs.io/en/production/dev/feedback-json/#feedback-json-doc
 	enum class FeedbackType
@@ -42,4 +42,4 @@ namespace Scrobbling::ListenBrainz
 
 	std::ostream& operator<<(std::ostream& os, const Feedback& feedback);
 
-} // Scrobbling::ListenBrainz
+} // Feedback::ListenBrainz
diff --git a/src/libs/services/feedback/impl/listenbrainz/FeedbacksParser.cpp b/src/libs/services/feedback/impl/listenbrainz/FeedbacksParser.cpp
new file mode 100644
index 00000000..123a0a2e
--- /dev/null
+++ b/src/libs/services/feedback/impl/listenbrainz/FeedbacksParser.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2022 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "FeedbacksParser.hpp"
+
+#include <Wt/Json/Array.h>
+#include <Wt/Json/Object.h>
+#include <Wt/Json/Value.h>
+#include <Wt/Json/Parser.h>
+
+#include "Exception.hpp"
+#include "Utils.hpp"
+
+namespace Feedback::ListenBrainz
+{
+    namespace
+    {
+        Feedback parseFeedback(const Wt::Json::Object& feedbackObj)
+        {
+            const std::optional<UUID> recordingMBID{ UUID::fromString(static_cast<std::string>(feedbackObj.get("recording_mbid"))) };
+            if (!recordingMBID)
+                throw Exception{ "MBID not found!" };
+
+            return Feedback
+            {
+                Wt::WDateTime::fromTime_t(static_cast<int>(feedbackObj.get("created"))),
+                    *recordingMBID,
+                    static_cast<FeedbackType>(static_cast<int>(feedbackObj.get("score")))
+            };
+        }
+    }
+
+    FeedbacksParser::Result FeedbacksParser::parse(std::string_view msgBody)
+    {
+        Result res;
+
+        try
+        {
+            Wt::Json::Object root;
+            Wt::Json::parse(std::string{ msgBody }, root);
+
+            const Wt::Json::Array& feedbacks = root.get("feedback");
+
+            LOG(DEBUG) << "Got " << feedbacks.size() << " feedbacks";
+
+            if (feedbacks.empty())
+                return res;
+
+            res.feedbackCount = feedbacks.size();
+
+            for (const Wt::Json::Value& value : feedbacks)
+            {
+                try
+                {
+                    res.feedbacks.push_back(parseFeedback(value));
+                }
+                catch (const Exception& e)
+                {
+                    LOG(DEBUG) << "Cannot parse feedback: " << e.what() << ", skipping";
+                }
+                catch (const Wt::WException& e)
+                {
+                    LOG(DEBUG) << "Cannot parse feedback: " << e.what() << ", skipping";
+                }
+            }
+        }
+        catch (const Wt::WException& error)
+        {
+            LOG(ERROR) << "Cannot parse 'feedback' result: " << error.what();
+        }
+
+        return res;
+    }
+} // Feedback::ListenBrainz
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/FeedbacksParser.hpp b/src/libs/services/feedback/impl/listenbrainz/FeedbacksParser.hpp
similarity index 93%
rename from src/libs/services/scrobbling/impl/listenbrainz/FeedbacksParser.hpp
rename to src/libs/services/feedback/impl/listenbrainz/FeedbacksParser.hpp
index d42098bd..f745ceda 100644
--- a/src/libs/services/scrobbling/impl/listenbrainz/FeedbacksParser.hpp
+++ b/src/libs/services/feedback/impl/listenbrainz/FeedbacksParser.hpp
@@ -23,7 +23,7 @@
 
 #include "FeedbackTypes.hpp"
 
-namespace Scrobbling::ListenBrainz
+namespace Feedback::ListenBrainz
 {
 	class FeedbacksParser
 	{
@@ -37,4 +37,4 @@ namespace Scrobbling::ListenBrainz
 			static Result parse(std::string_view msgBody);
 	};
 
-} // Scrobbling::ListenBrainz
+} // Feedback::ListenBrainz
diff --git a/src/libs/services/feedback/impl/listenbrainz/FeedbacksSynchronizer.cpp b/src/libs/services/feedback/impl/listenbrainz/FeedbacksSynchronizer.cpp
new file mode 100644
index 00000000..1cd2c64a
--- /dev/null
+++ b/src/libs/services/feedback/impl/listenbrainz/FeedbacksSynchronizer.cpp
@@ -0,0 +1,490 @@
+/*
+ * Copyright (C) 2021 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "FeedbacksSynchronizer.hpp"
+
+#include <boost/asio/bind_executor.hpp>
+#include <Wt/Json/Array.h>
+#include <Wt/Json/Object.h>
+#include <Wt/Json/Value.h>
+#include <Wt/Json/Serializer.h>
+
+#include "services/database/Db.hpp"
+#include "services/database/Session.hpp"
+#include "services/database/StarredTrack.hpp"
+#include "services/database/Track.hpp"
+#include "services/database/User.hpp"
+#include "utils/IConfig.hpp"
+#include "utils/http/IClient.hpp"
+#include "utils/Service.hpp"
+
+#include "Exception.hpp"
+#include "FeedbacksParser.hpp"
+#include "Utils.hpp"
+
+namespace Feedback::ListenBrainz
+{
+    namespace
+    {
+        std::optional<std::size_t> parseTotalFeedbackCount(std::string_view msgBody)
+        {
+            try
+            {
+                Wt::Json::Object root;
+                Wt::Json::parse(std::string{ msgBody }, root);
+
+                return static_cast<int>(root.get("total_count"));
+            }
+            catch (const Wt::WException& e)
+            {
+                LOG(ERROR) << "Cannot parse listen count response: " << e.what();
+                return std::nullopt;
+            }
+        }
+    }
+
+    FeedbacksSynchronizer::FeedbacksSynchronizer(boost::asio::io_context& ioContext, Database::Db& db, Http::IClient& client)
+        : _ioContext{ ioContext }
+        , _db{ db }
+        , _client{ client }
+        , _maxSyncFeedbackCount{ Service<IConfig>::get()->getULong("listenbrainz-max-sync-feedback-count", 1000) }
+        , _syncFeedbacksPeriod{ Service<IConfig>::get()->getULong("listenbrainz-sync-feedbacks-period-hours", 1) }
+    {
+        LOG(INFO) << "Starting Feedbacks synchronizer, maxSyncFeedbackCount = " << _maxSyncFeedbackCount << ", _syncFeedbacksPeriod = " << _syncFeedbacksPeriod.count() << " hours";
+
+        scheduleSync(std::chrono::seconds{ 30 });
+    }
+
+    void FeedbacksSynchronizer::enqueFeedback(FeedbackType type, Database::StarredTrackId starredTrackId)
+    {
+        try
+        {
+            Database::Session& session{ _db.getTLSSession() };
+
+            auto transaction{ session.createUniqueTransaction() };
+
+            Database::StarredTrack::pointer starredTrack{ Database::StarredTrack::find(session, starredTrackId) };
+            if (!starredTrack)
+                return;
+
+            std::optional<UUID> recordingMBID{ starredTrack->getTrack()->getRecordingMBID() };
+
+            switch (type)
+            {
+            case FeedbackType::Love:
+                if (starredTrack->getSyncState() != Database::SyncState::PendingAdd)
+                    starredTrack.modify()->setSyncState(Database::SyncState::PendingAdd);
+                break;
+
+            case FeedbackType::Erase:
+                if (!recordingMBID)
+                {
+                    LOG(DEBUG) << "Track has no recording MBID: erasing star";
+                    starredTrack.remove();
+                }
+                else
+                {
+                    // Send the erase order even if it is not on the remote LB server (it may be
+                    // queued for add, or not)
+                    starredTrack.modify()->setSyncState(Database::SyncState::PendingRemove);
+                }
+                break;
+
+            default:
+                throw Exception{ "Unhandled feedback type" };
+            }
+
+            if (!recordingMBID)
+            {
+                LOG(DEBUG) << "Track has no recording MBID: skipping";
+                return;
+            }
+
+            const std::optional<UUID> listenBrainzToken{ starredTrack->getUser()->getListenBrainzToken() };
+            if (!listenBrainzToken)
+                return;
+
+            Http::ClientPOSTRequestParameters request;
+            request.relativeUrl = "/1/feedback/recording-feedback";
+            request.message.addHeader("Authorization", "Token " + std::string{ listenBrainzToken->getAsString() });
+
+            Wt::Json::Object root;
+            root["recording_mbid"] = Wt::Json::Value{ std::string {recordingMBID->getAsString()} };
+            root["score"] = Wt::Json::Value{ static_cast<int>(type) };
+
+            request.message.addBodyText(Wt::Json::serialize(root));
+            request.message.addHeader("Content-Type", "application/json");
+
+            request.onSuccessFunc = [=](std::string_view /*msgBody*/)
+                {
+                    _strand.dispatch([=]
+                        {
+                            onFeedbackSent(type, starredTrackId);
+                        });
+                };
+            _client.sendPOSTRequest(std::move(request));
+        }
+        catch (Exception& e)
+        {
+            LOG(DEBUG) << "Cannot send feedback: " << e.what();
+        }
+    }
+
+    void FeedbacksSynchronizer::onFeedbackSent(FeedbackType type, Database::StarredTrackId starredTrackId)
+    {
+        assert(_strand.running_in_this_thread());
+
+        Database::Session& session{ _db.getTLSSession() };
+        auto transaction{ session.createUniqueTransaction() };
+
+        Database::StarredTrack::pointer starredTrack{ Database::StarredTrack::find(session, starredTrackId) };
+        if (!starredTrack)
+        {
+            LOG(DEBUG) << "Starred track not found. deleted?";
+            return;
+        }
+
+        UserContext& userContext{ getUserContext(starredTrack->getUser()->getId()) };
+
+        switch (type)
+        {
+        case FeedbackType::Love:
+            starredTrack.modify()->setSyncState(Database::SyncState::Synchronized);
+            LOG(DEBUG) << "State set to synchronized";
+
+            if (userContext.feedbackCount)
+            {
+                (*userContext.feedbackCount)++;
+                LOG(DEBUG) << "Feedback count set to " << *userContext.feedbackCount << " for user '" << userContext.listenBrainzUserName << "'";
+            }
+            break;
+
+        case FeedbackType::Erase:
+            starredTrack.remove();
+            LOG(DEBUG) << "Removed starred track";
+
+            if (userContext.feedbackCount && *userContext.feedbackCount > 0)
+            {
+                (*userContext.feedbackCount)--;
+                LOG(DEBUG) << "Feedback count set to " << *userContext.feedbackCount << " for user '" << userContext.listenBrainzUserName << "'";
+            }
+            break;
+
+        default:
+            throw Exception{ "Unhandled feedback type" };
+        }
+    }
+
+    void FeedbacksSynchronizer::enquePendingFeedbacks()
+    {
+    using namespace Database;
+
+        auto processPendingFeedbacks{ [this](SyncState scrobblingState, FeedbackType feedbackType)
+        {
+            RangeResults<StarredTrackId> pendingFeedbacks;
+
+            {
+                Database::Session& session {_db.getTLSSession()};
+
+                auto transaction {session.createSharedTransaction()};
+
+                StarredTrack::FindParameters params;
+                params.setFeedbackBackend(Database::FeedbackBackend::ListenBrainz, scrobblingState)
+                        .setRange(Database::Range {0, 100}); // don't flood too much?
+
+                pendingFeedbacks = StarredTrack::find(session, params);
+            }
+
+            LOG(DEBUG) << "Queing " << pendingFeedbacks.results.size() << " pending '" << (feedbackType == FeedbackType::Love ? "love" : "erase") << "' feedbacks";
+
+            for (const StarredTrackId starredTrackId : pendingFeedbacks.results)
+                enqueFeedback(feedbackType, starredTrackId);
+        } };
+
+        processPendingFeedbacks(SyncState::PendingAdd, FeedbackType::Love);
+        processPendingFeedbacks(SyncState::PendingRemove, FeedbackType::Erase);
+    }
+
+    FeedbacksSynchronizer::UserContext& FeedbacksSynchronizer::getUserContext(Database::UserId userId)
+    {
+        assert(_strand.running_in_this_thread());
+
+        auto itContext{ _userContexts.find(userId) };
+        if (itContext == std::cend(_userContexts))
+        {
+            std::tie(itContext, std::ignore) = _userContexts.emplace(userId, userId);
+        }
+
+        return itContext->second;
+    }
+
+    bool FeedbacksSynchronizer::isSyncing() const
+    {
+        return std::any_of(std::cbegin(_userContexts), std::cend(_userContexts), [](const auto& contextEntry)
+            {
+                return contextEntry.second.syncing;
+            });
+    }
+
+    void FeedbacksSynchronizer::scheduleSync(std::chrono::seconds fromNow)
+    {
+        if (_syncFeedbacksPeriod.count() == 0 || _maxSyncFeedbackCount == 0)
+            return;
+
+        LOG(DEBUG) << "Scheduled sync in " << fromNow.count() << " seconds...";
+        _syncTimer.expires_after(fromNow);
+        _syncTimer.async_wait(boost::asio::bind_executor(_strand, [this](const boost::system::error_code& ec)
+            {
+                if (ec == boost::asio::error::operation_aborted)
+                {
+                    LOG(DEBUG) << "getFeedbacks aborted";
+                    return;
+                }
+                else if (ec)
+                {
+                    throw Exception{ "GetFeedbacks timer failure: " + std::string {ec.message()} };
+                }
+
+                startSync();
+            }));
+    }
+
+    void FeedbacksSynchronizer::startSync()
+    {
+        LOG(DEBUG) << "Starting sync!";
+
+        assert(!isSyncing());
+        assert(_strand.running_in_this_thread());
+
+        enquePendingFeedbacks();
+
+        Database::RangeResults<Database::UserId> userIds;
+        {
+            Database::Session& session{ _db.getTLSSession() };
+            auto transaction{ session.createSharedTransaction() };
+            userIds = Database::User::find(_db.getTLSSession(), Database::User::FindParameters{}.setFeedbackBackend(Database::FeedbackBackend::ListenBrainz));
+        }
+
+        for (const Database::UserId userId : userIds.results)
+            startSync(getUserContext(userId));
+
+        if (!isSyncing())
+            scheduleSync(_syncFeedbacksPeriod);
+    }
+
+    void FeedbacksSynchronizer::startSync(UserContext& context)
+    {
+        context.syncing = true;
+        context.listenBrainzUserName = "";
+        context.fetchedFeedbackCount = 0;
+        context.matchedFeedbackCount = 0;
+        context.importedFeedbackCount = 0;
+
+        enqueValidateToken(context);
+    }
+
+    void FeedbacksSynchronizer::onSyncEnded(UserContext& context)
+    {
+        _strand.dispatch([this, &context]
+            {
+                LOG(INFO) << "Feedback sync done for user '" << context.listenBrainzUserName << "', fetched: " << context.fetchedFeedbackCount << ", matched: " << context.matchedFeedbackCount << ", imported: " << context.importedFeedbackCount;
+                context.syncing = false;
+
+                if (!isSyncing())
+                    scheduleSync(_syncFeedbacksPeriod);
+            });
+    }
+
+    void FeedbacksSynchronizer::enqueValidateToken(UserContext& context)
+    {
+        assert(context.listenBrainzUserName.empty());
+
+        const std::optional<UUID> listenBrainzToken{ ListenBrainz::Utils::getListenBrainzToken(_db.getTLSSession(), context.userId) };
+        if (!listenBrainzToken)
+        {
+            onSyncEnded(context);
+            return;
+        }
+
+        Http::ClientGETRequestParameters request;
+        request.priority = Http::ClientRequestParameters::Priority::Low;
+        request.relativeUrl = "/1/validate-token";
+        request.headers = { {"Authorization",  "Token " + std::string {listenBrainzToken->getAsString()}} };
+        request.onSuccessFunc = [this, &context](std::string_view msgBody)
+            {
+                context.listenBrainzUserName = ListenBrainz::Utils::parseValidateToken(msgBody);
+                if (context.listenBrainzUserName.empty())
+                {
+                    onSyncEnded(context);
+                    return;
+                }
+                enqueGetFeedbackCount(context);
+            };
+        request.onFailureFunc = [this, &context]
+            {
+                onSyncEnded(context);
+            };
+
+        _client.sendGETRequest(std::move(request));
+    }
+
+    void FeedbacksSynchronizer::enqueGetFeedbackCount(UserContext& context)
+    {
+        assert(!context.listenBrainzUserName.empty());
+
+        Http::ClientGETRequestParameters request;
+        request.relativeUrl = "/1/feedback/user/" + std::string{ context.listenBrainzUserName } + "/get-feedback?score=1&count=0";
+        request.priority = Http::ClientRequestParameters::Priority::Low;
+        request.onSuccessFunc = [this, &context](std::string_view msgBody)
+            {
+                std::string msgBodyCopy{ msgBody };
+                _strand.dispatch([this, msgBodyCopy, &context]
+                    {
+                        LOG(DEBUG) << "Current feedback count = " << (context.feedbackCount ? *context.feedbackCount : 0) << " for user '" << context.listenBrainzUserName << "'";
+
+                        const auto totalFeedbackCount = parseTotalFeedbackCount(msgBodyCopy);
+                        if (totalFeedbackCount)
+                            LOG(DEBUG) << "Feedback count for listenbrainz user '" << context.listenBrainzUserName << "' = " << *totalFeedbackCount;
+
+                        bool needSync{ totalFeedbackCount && (!context.feedbackCount || *context.feedbackCount != *totalFeedbackCount) };
+                        context.feedbackCount = totalFeedbackCount;
+
+                        if (needSync)
+                            enqueGetFeedbacks(context);
+                        else
+                            onSyncEnded(context);
+                    });
+            };
+        request.onFailureFunc = [this, &context]
+            {
+                onSyncEnded(context);
+            };
+
+        _client.sendGETRequest(std::move(request));
+    }
+
+    void FeedbacksSynchronizer::enqueGetFeedbacks(UserContext& context)
+    {
+        assert(!context.listenBrainzUserName.empty());
+
+        Http::ClientGETRequestParameters request;
+        request.relativeUrl = "/1/feedback/user/" + context.listenBrainzUserName + "/get-feedback?offset=" + std::to_string(context.fetchedFeedbackCount);
+        request.priority = Http::ClientRequestParameters::Priority::Low;
+        request.onSuccessFunc = [this, &context](std::string_view msgBody)
+            {
+                std::string msgBodyCopy{ msgBody };
+                _strand.dispatch([this, msgBodyCopy, &context]
+                    {
+                        const std::size_t fetchedFeedbackCount{ processGetFeedbacks(msgBodyCopy, context) };
+                        if (fetchedFeedbackCount == 0 // no more thing available on server
+                            || context.fetchedFeedbackCount >= context.feedbackCount // we may miss something, but we will get it next time
+                            || context.fetchedFeedbackCount >= _maxSyncFeedbackCount)
+                        {
+                            onSyncEnded(context);
+                        }
+                        else
+                        {
+                            enqueGetFeedbacks(context);
+                        }
+                    });
+            };
+        request.onFailureFunc = [=, &context]
+            {
+                onSyncEnded(context);
+            };
+
+        _client.sendGETRequest(std::move(request));
+    }
+
+    std::size_t FeedbacksSynchronizer::processGetFeedbacks(std::string_view msgBody, UserContext& context)
+    {
+        const FeedbacksParser::Result parseResult{ FeedbacksParser::parse(msgBody) };
+
+        LOG(DEBUG) << "Parsed " << parseResult.feedbackCount << " feedbacks, found " << parseResult.feedbacks.size() << " usable entries";
+        context.fetchedFeedbackCount += parseResult.feedbackCount;
+
+        for (const Feedback& feedback : parseResult.feedbacks)
+        {
+            tryImportFeedback(feedback, context);
+        }
+
+        return parseResult.feedbackCount;
+    }
+
+    void FeedbacksSynchronizer::tryImportFeedback(const Feedback& feedback, UserContext& context)
+    {
+        using namespace Database;
+
+        Session& session{ _db.getTLSSession() };
+
+        bool needImport{};
+        TrackId trackId;
+
+        {
+            auto transaction{ session.createSharedTransaction() };
+            const std::vector<Track::pointer> tracks{ Track::findByRecordingMBID(session, feedback.recordingMBID) };
+            if (tracks.size() > 1)
+            {
+                LOG(DEBUG) << "Too many matches for feedback '" << feedback << "': duplicate recording MBIDs found";
+                return;
+            }
+            else if (tracks.empty())
+            {
+                LOG(DEBUG) << "Cannot match feedback '" << feedback << "': no track found for this recording MBID";
+                return;
+            }
+
+            trackId = tracks.front()->getId();
+
+            const StarredTrack::pointer starredTrack{ StarredTrack::find(session, trackId, context.userId, Database::FeedbackBackend::ListenBrainz) };
+            needImport = !starredTrack;
+
+            // don't update starred date time
+            // no need to update state if it was found as not synchronized
+            // pending remove => will be removed later
+            // pending add => will be resent later
+        }
+
+        if (needImport)
+        {
+            LOG(DEBUG) << "Importing feedback '" << feedback << "'";
+
+            auto transaction{ session.createUniqueTransaction() };
+
+            const Track::pointer track{ Track::find(session, trackId) };
+            if (!track)
+                return;
+
+            const User::pointer user{ User::find(session, context.userId) };
+            if (!user)
+                return;
+
+            StarredTrack::pointer starredTrack{ session.create<StarredTrack>(track, user, Database::FeedbackBackend::ListenBrainz) };
+            starredTrack.modify()->setSyncState(SyncState::Synchronized);
+            starredTrack.modify()->setDateTime(feedback.created);
+
+            context.importedFeedbackCount++;
+        }
+        else
+        {
+            LOG(DEBUG) << "No need to import feedback '" << feedback << "', already imported";
+            context.matchedFeedbackCount++;
+        }
+    }
+} // namespace Feedback::ListenBrainz
diff --git a/src/libs/services/feedback/impl/listenbrainz/FeedbacksSynchronizer.hpp b/src/libs/services/feedback/impl/listenbrainz/FeedbacksSynchronizer.hpp
new file mode 100644
index 00000000..bbc2bfec
--- /dev/null
+++ b/src/libs/services/feedback/impl/listenbrainz/FeedbacksSynchronizer.hpp
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2021 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <optional>
+#include <unordered_map>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/io_context_strand.hpp>
+#include <boost/asio/steady_timer.hpp>
+
+#include "services/database/Types.hpp"
+#include "services/database/StarredTrackId.hpp"
+#include "services/database/UserId.hpp"
+
+#include "FeedbackTypes.hpp"
+
+namespace Database
+{
+    class Db;
+}
+
+namespace Http
+{
+    class IClient;
+}
+
+namespace Feedback::ListenBrainz
+{
+    class FeedbacksSynchronizer
+    {
+    public:
+        FeedbacksSynchronizer(boost::asio::io_context& ioContext, Database::Db& db, Http::IClient& client);
+
+        void enqueFeedback(FeedbackType type, Database::StarredTrackId starredTrackId);
+
+    private:
+        void onFeedbackSent(FeedbackType type, Database::StarredTrackId starredTrackId);
+
+        void enquePendingFeedbacks();
+
+        struct UserContext
+        {
+            UserContext(Database::UserId id) : userId{ id } {}
+
+            UserContext(const UserContext&) = delete;
+            UserContext& operator=(const UserContext&) = delete;
+            
+            const Database::UserId		userId;
+            bool						syncing{};
+            std::optional<std::size_t>	feedbackCount{};
+
+            // resetted at each sync
+            std::string		listenBrainzUserName; // need to be resolved first
+
+            std::size_t		currentOffset{};
+            std::size_t		fetchedFeedbackCount{};
+            std::size_t		matchedFeedbackCount{};
+            std::size_t		importedFeedbackCount{};
+        };
+
+        UserContext& getUserContext(Database::UserId userId);
+        bool isSyncing() const;
+        void scheduleSync(std::chrono::seconds fromNow);
+        void startSync();
+        void startSync(UserContext& context);
+        void onSyncEnded(UserContext& context);
+        void enqueValidateToken(UserContext& context);
+        void enqueGetFeedbackCount(UserContext& context);
+        void enqueGetFeedbacks(UserContext& context);
+        std::size_t processGetFeedbacks(std::string_view body, UserContext& context);
+        void tryImportFeedback(const Feedback& feedback, UserContext& context);
+
+        boost::asio::io_context& _ioContext;
+        boost::asio::io_context::strand	_strand{ _ioContext };
+        Database::Db& _db;
+        boost::asio::steady_timer		_syncTimer{ _ioContext };
+        Http::IClient& _client;
+
+        std::unordered_map<Database::UserId, UserContext> _userContexts;
+
+        const std::size_t			_maxSyncFeedbackCount;
+        const std::chrono::hours	_syncFeedbacksPeriod;
+    };
+} // Feedback::ListenBrainz
+
diff --git a/src/libs/services/feedback/impl/listenbrainz/ListenBrainzBackend.cpp b/src/libs/services/feedback/impl/listenbrainz/ListenBrainzBackend.cpp
new file mode 100644
index 00000000..d75a9072
--- /dev/null
+++ b/src/libs/services/feedback/impl/listenbrainz/ListenBrainzBackend.cpp
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2023 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ListenBrainzBackend.hpp"
+
+#include "services/database/Db.hpp"
+#include "services/database/Session.hpp"
+#include "services/database/StarredArtist.hpp"
+#include "services/database/StarredRelease.hpp"
+#include "services/database/Track.hpp"
+#include "utils/IConfig.hpp"
+#include "utils/http/IClient.hpp"
+#include "utils/Logger.hpp"
+#include "utils/Service.hpp"
+#include "Utils.hpp"
+
+namespace Feedback::ListenBrainz
+{
+    namespace details
+    {
+        template <typename StarredObjType>
+        void onStarred(Database::Session& session, typename StarredObjType::IdType id)
+        {
+            auto transaction{ session.createUniqueTransaction() };
+
+            if (auto starredObj{ StarredObjType::find(session, id) })
+            {
+                // maybe in the future this will be supported by ListenBrainz so set it to PendingAdd for all types
+                starredObj.modify()->setSyncState(Database::SyncState::PendingAdd);
+            }
+        }
+
+        template <typename StarredObjType>
+        void onUnstarred(Database::Session& session, typename StarredObjType::IdType id)
+        {
+            auto transaction{ session.createUniqueTransaction() };
+
+            if (auto starredObj{ StarredObjType::find(session, id) })
+                starredObj.remove();
+        }
+    }
+
+    ListenBrainzBackend::ListenBrainzBackend(boost::asio::io_context& ioContext, Database::Db& db)
+        : _ioContext{ ioContext }
+        , _db{ db }
+        , _baseAPIUrl{ Service<IConfig>::get()->getString("listenbrainz-api-base-url", "https://api.listenbrainz.org") }
+        , _client{ Http::createClient(_ioContext, _baseAPIUrl) }
+        , _feedbacksSynchronizer{ _ioContext, db, *_client }
+    {
+        LOG(INFO) << "Starting ListenBrainz feedback backend... API endpoint = '" << _baseAPIUrl << "'";
+    }
+
+    ListenBrainzBackend::~ListenBrainzBackend()
+    {
+        LOG(INFO) << "Stopped ListenBrainz feedback backend!";
+    }
+
+    void ListenBrainzBackend::onStarred(Database::StarredArtistId starredArtistId)
+    {
+        details::onStarred<Database::StarredArtist>(_db.getTLSSession(), starredArtistId);
+    }
+
+    void ListenBrainzBackend::onUnstarred(Database::StarredArtistId starredArtistId)
+    {
+        details::onUnstarred<Database::StarredArtist>(_db.getTLSSession(), starredArtistId);
+    }
+
+    void ListenBrainzBackend::onStarred(Database::StarredReleaseId starredReleaseId)
+    {
+        details::onStarred<Database::StarredRelease>(_db.getTLSSession(), starredReleaseId);
+    }
+
+    void ListenBrainzBackend::onUnstarred(Database::StarredReleaseId starredReleaseId)
+    {
+        details::onUnstarred<Database::StarredRelease>(_db.getTLSSession(), starredReleaseId);
+    }
+
+    void ListenBrainzBackend::onStarred(Database::StarredTrackId starredTrackId)
+    {
+        _feedbacksSynchronizer.enqueFeedback(FeedbackType::Love, starredTrackId);
+    }
+
+    void ListenBrainzBackend::onUnstarred(Database::StarredTrackId starredtrackId)
+    {
+        _feedbacksSynchronizer.enqueFeedback(FeedbackType::Erase, starredtrackId);
+    }
+} // namespace Scrobbling::ListenBrainz
diff --git a/src/libs/services/feedback/impl/listenbrainz/ListenBrainzBackend.hpp b/src/libs/services/feedback/impl/listenbrainz/ListenBrainzBackend.hpp
new file mode 100644
index 00000000..4f177b64
--- /dev/null
+++ b/src/libs/services/feedback/impl/listenbrainz/ListenBrainzBackend.hpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2023 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <boost/asio/io_context.hpp>
+
+#include "IFeedbackBackend.hpp"
+#include "FeedbacksSynchronizer.hpp"
+
+namespace Database
+{
+    class Db;
+}
+
+namespace Feedback::ListenBrainz
+{
+    class ListenBrainzBackend final : public IFeedbackBackend
+    {
+    public:
+        ListenBrainzBackend(boost::asio::io_context& ioContext, Database::Db& db);
+        ~ListenBrainzBackend() override;
+
+    private:
+        ListenBrainzBackend(const ListenBrainzBackend&) = delete;
+        ListenBrainzBackend& operator=(const ListenBrainzBackend&) = delete;
+
+        void onStarred(Database::StarredArtistId starredArtistId) override;
+        void onUnstarred(Database::StarredArtistId starredArtistId) override;
+        void onStarred(Database::StarredReleaseId starredReleaseId) override;
+        void onUnstarred(Database::StarredReleaseId starredReleaseId) override;
+        void onStarred(Database::StarredTrackId starredTrackId) override;
+        void onUnstarred(Database::StarredTrackId starredTrackId) override;
+
+        boost::asio::io_context& _ioContext;
+        Database::Db& _db;
+        std::string                     _baseAPIUrl;
+        std::unique_ptr<Http::IClient>  _client;
+        FeedbacksSynchronizer           _feedbacksSynchronizer;
+    };
+} // Feedback::ListenBrainz
+
diff --git a/src/libs/services/feedback/impl/listenbrainz/Utils.cpp b/src/libs/services/feedback/impl/listenbrainz/Utils.cpp
new file mode 100644
index 00000000..28b4de9d
--- /dev/null
+++ b/src/libs/services/feedback/impl/listenbrainz/Utils.cpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2021 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Utils.hpp"
+
+#include <Wt/Json/Object.h>
+#include <Wt/Json/Parser.h>
+
+#include "services/database/Session.hpp"
+#include "services/database/User.hpp"
+
+namespace Feedback::ListenBrainz::Utils
+{
+    std::optional<UUID> getListenBrainzToken(Database::Session& session, Database::UserId userId)
+    {
+        auto transaction{ session.createSharedTransaction() };
+
+        const Database::User::pointer user{ Database::User::find(session, userId) };
+        if (!user)
+            return std::nullopt;
+
+        return user->getListenBrainzToken();
+    }
+
+    std::string parseValidateToken(std::string_view msgBody)
+    {
+        std::string listenBrainzUserName;
+
+        Wt::Json::ParseError error;
+        Wt::Json::Object root;
+        if (!Wt::Json::parse(std::string{ msgBody }, root, error))
+        {
+            LOG(ERROR) << "Cannot parse 'validate-token' result: " << error.what();
+            return listenBrainzUserName;
+        }
+
+        if (!root.get("valid").orIfNull(false))
+        {
+            LOG(INFO) << "Invalid listenbrainz user";
+            return listenBrainzUserName;
+        }
+
+        listenBrainzUserName = root.get("user_name").orIfNull("");
+        return listenBrainzUserName;
+    }
+}
diff --git a/src/libs/services/feedback/impl/listenbrainz/Utils.hpp b/src/libs/services/feedback/impl/listenbrainz/Utils.hpp
new file mode 100644
index 00000000..fcbd3d9c
--- /dev/null
+++ b/src/libs/services/feedback/impl/listenbrainz/Utils.hpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "services/database/UserId.hpp"
+#include "utils/Logger.hpp"
+#include "utils/UUID.hpp"
+
+#define LOG(sev)	LMS_LOG(FEEDBACK, sev) << "[listenbrainz] "
+
+namespace Database
+{
+	class Session;
+}
+
+namespace Feedback::ListenBrainz::Utils
+{
+	std::optional<UUID>	getListenBrainzToken(Database::Session& session, Database::UserId userId);
+	std::string parseValidateToken(std::string_view msgBody);
+}
diff --git a/src/libs/services/feedback/include/services/feedback/Exception.hpp b/src/libs/services/feedback/include/services/feedback/Exception.hpp
new file mode 100644
index 00000000..1a8414fb
--- /dev/null
+++ b/src/libs/services/feedback/include/services/feedback/Exception.hpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2019 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "utils/Exception.hpp"
+
+namespace Feedback
+{
+    class Exception : public LmsException
+    {
+    public:
+        using LmsException::LmsException;
+    };
+}
diff --git a/src/libs/services/feedback/include/services/feedback/IFeedbackService.hpp b/src/libs/services/feedback/include/services/feedback/IFeedbackService.hpp
new file mode 100644
index 00000000..dbd8085f
--- /dev/null
+++ b/src/libs/services/feedback/include/services/feedback/IFeedbackService.hpp
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2023 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <boost/asio/io_service.hpp>
+#include <Wt/WDateTime.h>
+
+#include "services/database/Types.hpp"
+#include "services/database/ArtistId.hpp"
+#include "services/database/ClusterId.hpp"
+#include "services/database/ReleaseId.hpp"
+#include "services/database/TrackId.hpp"
+#include "services/database/UserId.hpp"
+#include "services/database/Types.hpp"
+
+namespace Database
+{
+    class Db;
+}
+
+namespace Feedback
+{
+    class IFeedbackService
+    {
+    public:
+        virtual ~IFeedbackService() = default;
+
+        using ArtistContainer = Database::RangeResults<Database::ArtistId>;
+        using ReleaseContainer = Database::RangeResults<Database::ReleaseId>;
+        using TrackContainer = Database::RangeResults<Database::TrackId>;
+
+        virtual void            star(Database::UserId userId, Database::ArtistId artistId) = 0;
+        virtual void            unstar(Database::UserId userId, Database::ArtistId artistId) = 0;
+        virtual bool            isStarred(Database::UserId userId, Database::ArtistId artistId) = 0;
+        virtual Wt::WDateTime   getStarredDateTime(Database::UserId userId, Database::ArtistId artistId) = 0;
+        virtual ArtistContainer	getStarredArtists(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, std::optional<Database::TrackArtistLinkType> linkType, Database::ArtistSortMethod sortMethod, Database::Range range) = 0;
+
+        virtual void                star(Database::UserId userId, Database::ReleaseId releaseId) = 0;
+        virtual void                unstar(Database::UserId userId, Database::ReleaseId releaseId) = 0;
+        virtual bool                isStarred(Database::UserId userId, Database::ReleaseId artistId) = 0;
+        virtual Wt::WDateTime       getStarredDateTime(Database::UserId userId, Database::ReleaseId artistId) = 0;
+        virtual ReleaseContainer    getStarredReleases(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) = 0;
+
+        virtual void                star(Database::UserId userId, Database::TrackId trackId) = 0;
+        virtual void                unstar(Database::UserId userId, Database::TrackId trackId) = 0;
+        virtual bool                isStarred(Database::UserId userId, Database::TrackId artistId) = 0;
+        virtual Wt::WDateTime       getStarredDateTime(Database::UserId userId, Database::TrackId artistId) = 0;
+        virtual TrackContainer      getStarredTracks(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) = 0;
+    };
+
+    std::unique_ptr<IFeedbackService> createFeedbackService(boost::asio::io_service& ioService, Database::Db& db);
+
+} // ns Feedback
+
diff --git a/src/libs/services/recommendation/impl/PlaylistGeneratorService.cpp b/src/libs/services/recommendation/impl/PlaylistGeneratorService.cpp
index b136e9b4..6e235aea 100644
--- a/src/libs/services/recommendation/impl/PlaylistGeneratorService.cpp
+++ b/src/libs/services/recommendation/impl/PlaylistGeneratorService.cpp
@@ -30,89 +30,86 @@
 
 namespace Recommendation
 {
-	using namespace Database;
+    using namespace Database;
 
-	std::unique_ptr<IPlaylistGeneratorService>
-	createPlaylistGeneratorService(Db& db, Recommendation::IRecommendationService& recommendationService)
-	{
-		return std::make_unique<PlaylistGeneratorService>(db, recommendationService);
-	}
+    std::unique_ptr<IPlaylistGeneratorService> createPlaylistGeneratorService(Db& db, Recommendation::IRecommendationService& recommendationService)
+    {
+        return std::make_unique<PlaylistGeneratorService>(db, recommendationService);
+    }
 
-	PlaylistGeneratorService::PlaylistGeneratorService(Db& db, Recommendation::IRecommendationService& recommendationService)
-		: _db {db}
-	, _recommendationService {recommendationService}
-	{
-		_constraints.push_back(std::make_unique<PlaylistGeneratorConstraint::ConsecutiveArtists>(_db));
-		_constraints.push_back(std::make_unique<PlaylistGeneratorConstraint::ConsecutiveReleases>(_db));
-		_constraints.push_back(std::make_unique<PlaylistGeneratorConstraint::DuplicateTracks>());
-	}
+    PlaylistGeneratorService::PlaylistGeneratorService(Db& db, Recommendation::IRecommendationService& recommendationService)
+        : _db{ db }
+        , _recommendationService{ recommendationService }
+    {
+        _constraints.push_back(std::make_unique<PlaylistGeneratorConstraint::ConsecutiveArtists>(_db));
+        _constraints.push_back(std::make_unique<PlaylistGeneratorConstraint::ConsecutiveReleases>(_db));
+        _constraints.push_back(std::make_unique<PlaylistGeneratorConstraint::DuplicateTracks>());
+    }
 
-	std::vector<TrackId>
-	PlaylistGeneratorService::extendPlaylist(TrackListId tracklistId, std::size_t maxCount) const
-	{
-		LMS_LOG(RECOMMENDATION, DEBUG) << "Requested to extend playlist by " << maxCount << " similar tracks";
+    std::vector<TrackId> PlaylistGeneratorService::extendPlaylist(TrackListId tracklistId, std::size_t maxCount) const
+    {
+        LMS_LOG(RECOMMENDATION, DEBUG) << "Requested to extend playlist by " << maxCount << " similar tracks";
 
-		// supposed to be ordered from most similar to least similar
-		std::vector<TrackId> similarTracks {_recommendationService.findSimilarTracks(tracklistId, maxCount * 2)}; // ask for more tracks than we need as it will be easier to respect constraints
+        // supposed to be ordered from most similar to least similar
+        std::vector<TrackId> similarTracks{ _recommendationService.findSimilarTracks(tracklistId, maxCount * 2) }; // ask for more tracks than we need as it will be easier to respect constraints
 
-		const std::vector<TrackId> startingTracks {getTracksFromTrackList(tracklistId)};
+        const std::vector<TrackId> startingTracks{ getTracksFromTrackList(tracklistId) };
 
-		std::vector<TrackId> finalResult = startingTracks;
-		finalResult.reserve(startingTracks.size() + maxCount);
+        std::vector<TrackId> finalResult = startingTracks;
+        finalResult.reserve(startingTracks.size() + maxCount);
 
-		std::vector<float> scores;
-		for (std::size_t i {}; i < maxCount; ++i)
-		{
-			if (similarTracks.empty())
-				break;
+        std::vector<float> scores;
+        for (std::size_t i{}; i < maxCount; ++i)
+        {
+            if (similarTracks.empty())
+                break;
 
-			scores.resize(similarTracks.size(), {});
+            scores.resize(similarTracks.size(), {});
 
-			// select the similar track that has the best score
-			for (std::size_t trackIndex {}; trackIndex < similarTracks.size(); ++trackIndex)
-			{
-				using namespace Database::Debug;
+            // select the similar track that has the best score
+            for (std::size_t trackIndex{}; trackIndex < similarTracks.size(); ++trackIndex)
+            {
+                using namespace Database::Debug;
 
-				finalResult.push_back(similarTracks[trackIndex]);
+                finalResult.push_back(similarTracks[trackIndex]);
 
-				scores[trackIndex] = 0;
-				for (const auto& constraint : _constraints)
-					scores[trackIndex] += constraint->computeScore(finalResult, finalResult.size() - 1);
+                scores[trackIndex] = 0;
+                for (const auto& constraint : _constraints)
+                    scores[trackIndex] += constraint->computeScore(finalResult, finalResult.size() - 1);
 
-				finalResult.pop_back();
+                finalResult.pop_back();
 
-				// early exit if we consider we found a track with no constraint violation (since similarTracks sorted from most to least similar)
-				if (scores[trackIndex] < 0.01)
-					break;
-			}
+                // early exit if we consider we found a track with no constraint violation (since similarTracks sorted from most to least similar)
+                if (scores[trackIndex] < 0.01)
+                    break;
+            }
 
-			// get the best score
-			const std::size_t bestScoreIndex {static_cast<std::size_t>(std::distance(std::cbegin(scores), std::min_element(std::cbegin(scores), std::cend(scores))))};
+            // get the best score
+            const std::size_t bestScoreIndex{ static_cast<std::size_t>(std::distance(std::cbegin(scores), std::min_element(std::cbegin(scores), std::cend(scores)))) };
 
-			finalResult.push_back(similarTracks[bestScoreIndex]);
-			similarTracks.erase(std::begin(similarTracks) + bestScoreIndex);
-		}
+            finalResult.push_back(similarTracks[bestScoreIndex]);
+            similarTracks.erase(std::begin(similarTracks) + bestScoreIndex);
+        }
 
-		// for now, just get some more similar tracks
-		return std::vector(std::cbegin(finalResult) + startingTracks.size(), std::cend(finalResult));
-	}
+        // for now, just get some more similar tracks
+        return std::vector(std::cbegin(finalResult) + startingTracks.size(), std::cend(finalResult));
+    }
 
-	TrackContainer
-	PlaylistGeneratorService::getTracksFromTrackList(Database::TrackListId tracklistId) const
-	{
-		TrackContainer tracks;
+    TrackContainer PlaylistGeneratorService::getTracksFromTrackList(Database::TrackListId tracklistId) const
+    {
+        TrackContainer tracks;
 
-		Session& dbSession {_db.getTLSSession()};
-		auto transaction {dbSession.createSharedTransaction()};
+        Session& dbSession{ _db.getTLSSession() };
+        auto transaction{ dbSession.createSharedTransaction() };
 
-		Track::FindParameters params;
-		params.setTrackList(tracklistId);
-		params.setSortMethod(TrackSortMethod::TrackList);
-		params.setDistinct(false);
+        Track::FindParameters params;
+        params.setTrackList(tracklistId);
+        params.setSortMethod(TrackSortMethod::TrackList);
+        params.setDistinct(false);
 
-		for (const TrackId trackId : Track::find(dbSession, params).results)
-			tracks.push_back(trackId);
+        for (const TrackId trackId : Track::findIds(dbSession, params).results)
+            tracks.push_back(trackId);
 
-		return tracks;
-	}
+        return tracks;
+    }
 }
diff --git a/src/libs/services/recommendation/impl/RecommendationService.cpp b/src/libs/services/recommendation/impl/RecommendationService.cpp
index dd302c6b..4ec0ac75 100644
--- a/src/libs/services/recommendation/impl/RecommendationService.cpp
+++ b/src/libs/services/recommendation/impl/RecommendationService.cpp
@@ -90,6 +90,8 @@ namespace Recommendation
 			if (itEngine == std::cend(_engines))
 				continue;
 
+			LMS_LOG(RECOMMENDATION, DEBUG) << "Trying engine '" << engineTypeToString(engineType) << "' to get similar tracks";
+
 			const IEngine& engine {*itEngine->second};
 			res = engine.findSimilarTracks(trackIds, maxCount);
 			if (!res.empty())
@@ -114,6 +116,8 @@ namespace Recommendation
 			if (itEngine == std::cend(_engines))
 				continue;
 
+			LMS_LOG(RECOMMENDATION, DEBUG) << "Trying engine '" << engineTypeToString(engineType) << "' to get similar releases";
+
 			const IEngine& engine {*itEngine->second};
 			res = engine.getSimilarReleases(releaseId, maxCount);
 			if (!res.empty())
@@ -140,7 +144,7 @@ namespace Recommendation
 			if (itEngine == std::cend(_engines))
 				continue;
 
-			LMS_LOG(RECOMMENDATION, DEBUG) << "Trying engine '" << engineTypeToString(engineType) << "'";
+			LMS_LOG(RECOMMENDATION, DEBUG) << "Trying engine '" << engineTypeToString(engineType) << "' to get similar artists";
 
 			const IEngine& engine {*itEngine->second};
 			res = engine.getSimilarArtists(artistId, linkTypes, maxCount);
@@ -155,12 +159,12 @@ namespace Recommendation
 	}
 
 	static
-	Database::ScanSettings::RecommendationEngineType
-	getRecommendationEngineType(Database::Session& session)
+	Database::ScanSettings::SimilarityEngineType
+	getSimilarityEngineType(Database::Session& session)
 	{
 		auto transaction {session.createSharedTransaction()};
 
-		return Database::ScanSettings::get(session)->getRecommendationEngineType();
+		return Database::ScanSettings::get(session)->getSimilarityEngineType();
 	}
 
 	void
@@ -180,20 +184,24 @@ namespace Recommendation
 				_engines.clear();
 			}
 
-			switch (getRecommendationEngineType(_db.getTLSSession()))
+			switch (getSimilarityEngineType(_db.getTLSSession()))
 			{
-				case ScanSettings::RecommendationEngineType::Clusters:
+				case ScanSettings::SimilarityEngineType::Clusters:
 					_enginePriorities = {EngineType::Clusters};
 					enginesToLoad.try_emplace(EngineType::Clusters, createClustersEngine(_db));
 					break;
 
-				case ScanSettings::RecommendationEngineType::Features:
+				case ScanSettings::SimilarityEngineType::Features:
 					_enginePriorities = {EngineType::Features, EngineType::Clusters};
 
 					// not same order since clusters is faster to load
 					enginesToLoad.try_emplace(EngineType::Clusters, createClustersEngine(_db));
 					enginesToLoad.try_emplace(EngineType::Features, createFeaturesEngine(_db));
 					break;
+
+				case ScanSettings::SimilarityEngineType::None:
+					_enginePriorities.clear();
+					break;
 			}
 
 			assert(_pendingEngines.empty());
diff --git a/src/libs/services/recommendation/impl/clusters/ClustersEngine.cpp b/src/libs/services/recommendation/impl/clusters/ClustersEngine.cpp
index ce8abc37..d34fb6f6 100644
--- a/src/libs/services/recommendation/impl/clusters/ClustersEngine.cpp
+++ b/src/libs/services/recommendation/impl/clusters/ClustersEngine.cpp
@@ -44,7 +44,7 @@ namespace Recommendation {
         Session& dbSession{ _db.getTLSSession() };
         auto transaction{ dbSession.createSharedTransaction() };
 
-        const auto similarTrackIds{ Track::findSimilarTracks(dbSession, trackIds, Range {0, maxCount}) };
+        const auto similarTrackIds{ Track::findSimilarTrackIds(dbSession, trackIds, Range {0, maxCount}) };
         return std::move(similarTrackIds.results);
     }
 
@@ -104,7 +104,7 @@ namespace Recommendation {
         if (!artist)
             return {};
 
-        const auto similarArtistIds{ artist->findSimilarArtists(artistLinkTypes, Range {0, maxCount}) };
+        const auto similarArtistIds{ artist->findSimilarArtistIds(artistLinkTypes, Range {0, maxCount}) };
         return std::move(similarArtistIds.results);
     }
 
diff --git a/src/libs/services/scanner/impl/ScanStepCheckDuplicatedDbFiles.cpp b/src/libs/services/scanner/impl/ScanStepCheckDuplicatedDbFiles.cpp
index 8d1a0773..0e18f4a5 100644
--- a/src/libs/services/scanner/impl/ScanStepCheckDuplicatedDbFiles.cpp
+++ b/src/libs/services/scanner/impl/ScanStepCheckDuplicatedDbFiles.cpp
@@ -37,7 +37,7 @@ namespace Scanner
 		Session& session {_db.getTLSSession()};
 		auto transaction {session.createSharedTransaction()};
 
-		const RangeResults<TrackId> tracks = Track::findTrackMBIDDuplicates(session, Range {});
+		const RangeResults<TrackId> tracks = Track::findIdsTrackMBIDDuplicates(session, Range {});
 		for (const TrackId trackId : tracks.results)
 		{
 			const Track::pointer track {Track::find(session, trackId)};
diff --git a/src/libs/services/scanner/impl/ScanStepRemoveOrphanDbFiles.cpp b/src/libs/services/scanner/impl/ScanStepRemoveOrphanDbFiles.cpp
index 5b57416d..a9572fac 100644
--- a/src/libs/services/scanner/impl/ScanStepRemoveOrphanDbFiles.cpp
+++ b/src/libs/services/scanner/impl/ScanStepRemoveOrphanDbFiles.cpp
@@ -137,7 +137,7 @@ namespace Scanner
 		Session& session {_db.getTLSSession()};
 		auto transaction {session.createUniqueTransaction()};
 
-		auto artistIds {Artist::findAllOrphans(session, Range {})};
+		auto artistIds {Artist::findOrphanIds(session, Range {})};
 		for (const ArtistId artistId : artistIds.results)
 		{
 			Artist::pointer artist {Artist::find(session, artistId)};
@@ -153,10 +153,11 @@ namespace Scanner
 
 		LMS_LOG(DBUPDATER, DEBUG) << "Checking orphan releases...";
 
+		// TODO, by batch
 		Session& session {_db.getTLSSession()};
 		auto transaction {session.createUniqueTransaction()};
 
-		auto releases {Release::findOrphans(session, Range {})};
+		auto releases {Release::findOrphanIds(session, Range {})};
 		for (const ReleaseId releaseId : releases.results)
 		{
 			Release::pointer release {Release::find(session, releaseId)};
diff --git a/src/libs/services/scanner/impl/ScanStepScanFiles.cpp b/src/libs/services/scanner/impl/ScanStepScanFiles.cpp
index 76d29439..86820bd5 100644
--- a/src/libs/services/scanner/impl/ScanStepScanFiles.cpp
+++ b/src/libs/services/scanner/impl/ScanStepScanFiles.cpp
@@ -307,6 +307,10 @@ namespace Scanner
 
 				context.currentStepStats.processedElems++;
 				_progressCallback(context.currentStepStats);
+
+				// optimize the database during scan (if we import a very large database, it may be too late to do it once at end)
+				if ((context.stats.nbChanges() % 5'000) == 0)
+					_db.getTLSSession().optimize();
 			}
 
 			return true;
diff --git a/src/libs/services/scanner/impl/ScannerService.cpp b/src/libs/services/scanner/impl/ScannerService.cpp
index 4c4c1b95..3fa41ed2 100644
--- a/src/libs/services/scanner/impl/ScannerService.cpp
+++ b/src/libs/services/scanner/impl/ScannerService.cpp
@@ -381,7 +381,7 @@ ScannerService::readSettings()
 			std::transform(std::cbegin(fileExtensions), std::end(fileExtensions), std::back_inserter(newSettings.supportedExtensions),
 				[](const std::filesystem::path& extension) { return std::filesystem::path{ StringUtils::stringToLower(extension.string()) }; });
 		}
-		newSettings.recommendationServiceType = scanSettings->getRecommendationEngineType();
+		newSettings.similarityServiceType = scanSettings->getSimilarityEngineType();
 		newSettings.mediaDirectory = scanSettings->getMediaDirectory();
 
 		const auto clusterTypes = scanSettings->getClusterTypes();
diff --git a/src/libs/services/scanner/impl/ScannerSettings.hpp b/src/libs/services/scanner/impl/ScannerSettings.hpp
index 6f7af993..a102dea3 100644
--- a/src/libs/services/scanner/impl/ScannerSettings.hpp
+++ b/src/libs/services/scanner/impl/ScannerSettings.hpp
@@ -34,7 +34,7 @@ namespace Scanner
 		Wt::WTime											startTime;
 		Database::ScanSettings::UpdatePeriod 				updatePeriod {Database::ScanSettings::UpdatePeriod::Never};
 		std::vector<std::filesystem::path>					supportedExtensions;
-		Database::ScanSettings::RecommendationEngineType	recommendationServiceType;
+		Database::ScanSettings::SimilarityEngineType		similarityServiceType;
 		std::filesystem::path								mediaDirectory;
 		bool												skipDuplicateMBID {};
 		std::set<std::string>								clusterTypeNames;
@@ -45,7 +45,7 @@ namespace Scanner
 				&& startTime == rhs.startTime
 				&& updatePeriod == rhs.updatePeriod
 				&& supportedExtensions == rhs.supportedExtensions
-				&& recommendationServiceType == rhs.recommendationServiceType
+				&& similarityServiceType == rhs.similarityServiceType
 				&& mediaDirectory == rhs.mediaDirectory
 				&& skipDuplicateMBID == rhs.skipDuplicateMBID
 				&& clusterTypeNames == rhs.clusterTypeNames;
diff --git a/src/libs/services/scrobbling/CMakeLists.txt b/src/libs/services/scrobbling/CMakeLists.txt
index 087a3236..2f78000a 100644
--- a/src/libs/services/scrobbling/CMakeLists.txt
+++ b/src/libs/services/scrobbling/CMakeLists.txt
@@ -1,10 +1,7 @@
 
 add_library(lmsscrobbling SHARED
-	impl/internal/InternalScrobbler.cpp
-	impl/listenbrainz/FeedbacksParser.cpp
-	impl/listenbrainz/FeedbacksSynchronizer.cpp
-	impl/listenbrainz/FeedbackTypes.cpp
-	impl/listenbrainz/ListenBrainzScrobbler.cpp
+	impl/internal/InternalBackend.cpp
+	impl/listenbrainz/ListenBrainzBackend.cpp
 	impl/listenbrainz/ListenTypes.cpp
 	impl/listenbrainz/ListensParser.cpp
 	impl/listenbrainz/ListensSynchronizer.cpp
diff --git a/src/libs/services/scrobbling/impl/IScrobblingBackend.hpp b/src/libs/services/scrobbling/impl/IScrobblingBackend.hpp
new file mode 100644
index 00000000..e8db366d
--- /dev/null
+++ b/src/libs/services/scrobbling/impl/IScrobblingBackend.hpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2021 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <chrono>
+#include <memory>
+#include <optional>
+
+#include "services/scrobbling/Listen.hpp"
+
+namespace Database
+{
+    class Session;
+    class TrackList;
+    class User;
+}
+
+namespace Scrobbling
+{
+    class IScrobblingBackend
+    {
+    public:
+        virtual ~IScrobblingBackend() = default;
+
+        // Listens
+        virtual void listenStarted(const Listen& listen) = 0;
+        virtual void listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration) = 0;
+        virtual void addTimedListen(const TimedListen& listen) = 0;
+    };
+} // ns Scrobbling
+
diff --git a/src/libs/services/scrobbling/impl/ScrobblingService.cpp b/src/libs/services/scrobbling/impl/ScrobblingService.cpp
index af331af5..b28b64e2 100644
--- a/src/libs/services/scrobbling/impl/ScrobblingService.cpp
+++ b/src/libs/services/scrobbling/impl/ScrobblingService.cpp
@@ -18,22 +18,18 @@
  */
 
 #include "ScrobblingService.hpp"
-#include "ScrobblingService.impl.hpp"
 
 #include "services/database/Artist.hpp"
 #include "services/database/Db.hpp"
 #include "services/database/Listen.hpp"
 #include "services/database/Release.hpp"
 #include "services/database/Session.hpp"
-#include "services/database/StarredArtist.hpp"
-#include "services/database/StarredRelease.hpp"
-#include "services/database/StarredTrack.hpp"
 #include "services/database/Track.hpp"
 #include "services/database/User.hpp"
 #include "utils/Logger.hpp"
 
-#include "internal/InternalScrobbler.hpp"
-#include "listenbrainz/ListenBrainzScrobbler.hpp"
+#include "internal/InternalBackend.hpp"
+#include "listenbrainz/ListenBrainzBackend.hpp"
 
 namespace Scrobbling
 {
@@ -48,8 +44,8 @@ namespace Scrobbling
         : _db{ db }
     {
         LMS_LOG(SCROBBLING, INFO) << "Starting service...";
-        _scrobblers.emplace(Scrobbler::Internal, std::make_unique<InternalScrobbler>(_db));
-        _scrobblers.emplace(Scrobbler::ListenBrainz, std::make_unique<ListenBrainz::Scrobbler>(ioContext, _db));
+        _scrobblingBackends.emplace(ScrobblingBackend::Internal, std::make_unique<InternalBackend>(_db));
+        _scrobblingBackends.emplace(ScrobblingBackend::ListenBrainz, std::make_unique<ListenBrainz::ListenBrainzBackend>(ioContext, _db));
         LMS_LOG(SCROBBLING, INFO) << "Service started!";
     }
 
@@ -60,46 +56,46 @@ namespace Scrobbling
 
     void ScrobblingService::listenStarted(const Listen& listen)
     {
-        if (std::optional<Scrobbler> scrobbler{ getUserScrobbler(listen.userId) })
-            _scrobblers[*scrobbler]->listenStarted(listen);
+        if (std::optional<ScrobblingBackend> backend{ getUserBackend(listen.userId) })
+            _scrobblingBackends[*backend]->listenStarted(listen);
     }
 
     void ScrobblingService::listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration)
     {
-        if (std::optional<Scrobbler> scrobbler{ getUserScrobbler(listen.userId) })
-            _scrobblers[*scrobbler]->listenFinished(listen, duration);
+        if (std::optional<ScrobblingBackend> backend{ getUserBackend(listen.userId) })
+            _scrobblingBackends[*backend]->listenFinished(listen, duration);
     }
 
     void ScrobblingService::addTimedListen(const TimedListen& listen)
     {
-        if (std::optional<Scrobbler> scrobbler{ getUserScrobbler(listen.userId) })
-            _scrobblers[*scrobbler]->addTimedListen(listen);
+        if (std::optional<ScrobblingBackend> backend{ getUserBackend(listen.userId) })
+            _scrobblingBackends[*backend]->addTimedListen(listen);
     }
 
-    std::optional<Scrobbler> ScrobblingService::getUserScrobbler(UserId userId)
+    std::optional<ScrobblingBackend> ScrobblingService::getUserBackend(UserId userId)
     {
-        std::optional<Scrobbler> scrobbler;
+        std::optional<ScrobblingBackend> backend;
 
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createSharedTransaction() };
         if (const User::pointer user{ User::find(session, userId) })
-            scrobbler = user->getScrobbler();
+            backend = user->getScrobblingBackend();
 
-        return scrobbler;
+        return backend;
     }
 
     ScrobblingService::ArtistContainer ScrobblingService::getRecentArtists(UserId userId, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, Range range)
     {
         ArtistContainer res;
 
-        auto scrobbler{ getUserScrobbler(userId) };
-        if (!scrobbler)
+        const auto backend{ getUserBackend(userId) };
+        if (!backend)
             return res;
 
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createSharedTransaction() };
 
-        res = Database::Listen::getRecentArtists(session, userId, *scrobbler, clusterIds, linkType, range);
+        res = Database::Listen::getRecentArtists(session, userId, *backend, clusterIds, linkType, range);
         return res;
     }
 
@@ -107,14 +103,14 @@ namespace Scrobbling
     {
         ReleaseContainer res;
 
-        auto scrobbler{ getUserScrobbler(userId) };
-        if (!scrobbler)
+        const auto backend{ getUserBackend(userId) };
+        if (!backend)
             return res;
 
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createSharedTransaction() };
 
-        res = Database::Listen::getRecentReleases(session, userId, *scrobbler, clusterIds, range);
+        res = Database::Listen::getRecentReleases(session, userId, *backend, clusterIds, range);
         return res;
     }
 
@@ -122,40 +118,40 @@ namespace Scrobbling
     {
         TrackContainer res;
 
-        auto scrobbler{ getUserScrobbler(userId) };
-        if (!scrobbler)
+        const auto backend{ getUserBackend(userId) };
+        if (!backend)
             return res;
 
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createSharedTransaction() };
 
-        res = Database::Listen::getRecentTracks(session, userId, *scrobbler, clusterIds, range);
+        res = Database::Listen::getRecentTracks(session, userId, *backend, clusterIds, range);
         return res;
     }
 
     Wt::WDateTime ScrobblingService::getLastListenDateTime(Database::UserId userId, Database::ReleaseId releaseId)
     {
-        auto scrobbler{ getUserScrobbler(userId) };
-        if (!scrobbler)
+        const auto backend{ getUserBackend(userId) };
+        if (!backend)
             return {};
 
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createSharedTransaction() };
 
-        const Database::Listen::pointer listen{ Database::Listen::getMostRecentListen(session, userId, *scrobbler, releaseId) };
+        const Database::Listen::pointer listen{ Database::Listen::getMostRecentListen(session, userId, *backend, releaseId) };
         return listen ? listen->getDateTime() : Wt::WDateTime{};
     }
 
     Wt::WDateTime ScrobblingService::getLastListenDateTime(Database::UserId userId, Database::TrackId trackId)
     {
-        auto scrobbler{ getUserScrobbler(userId) };
-        if (!scrobbler)
+        const auto backend{ getUserBackend(userId) };
+        if (!backend)
             return {};
 
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createSharedTransaction() };
 
-        const Database::Listen::pointer listen{ Database::Listen::getMostRecentListen(session, userId, *scrobbler, trackId) };
+        const Database::Listen::pointer listen{ Database::Listen::getMostRecentListen(session, userId, *backend, trackId) };
         return listen ? listen->getDateTime() : Wt::WDateTime{};
     }
 
@@ -164,14 +160,14 @@ namespace Scrobbling
     {
         ArtistContainer res;
 
-        auto scrobbler{ getUserScrobbler(userId) };
-        if (!scrobbler)
+        const auto backend{ getUserBackend(userId) };
+        if (!backend)
             return res;
 
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createSharedTransaction() };
 
-        res = Database::Listen::getTopArtists(session, userId, *scrobbler, clusterIds, linkType, range);
+        res = Database::Listen::getTopArtists(session, userId, *backend, clusterIds, linkType, range);
         return res;
     }
 
@@ -179,14 +175,14 @@ namespace Scrobbling
     {
         ReleaseContainer res;
 
-        auto scrobbler{ getUserScrobbler(userId) };
-        if (!scrobbler)
+        const auto backend{ getUserBackend(userId) };
+        if (!backend)
             return res;
 
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createSharedTransaction() };
 
-        res = Database::Listen::getTopReleases(session, userId, *scrobbler, clusterIds, range);
+        res = Database::Listen::getTopReleases(session, userId, *backend, clusterIds, range);
         return res;
     }
 
@@ -194,133 +190,15 @@ namespace Scrobbling
     {
         TrackContainer res;
 
-        auto scrobbler{ getUserScrobbler(userId) };
-        if (!scrobbler)
+        const auto backend{ getUserBackend(userId) };
+        if (!backend)
             return res;
 
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createSharedTransaction() };
 
-        res = Database::Listen::getTopTracks(session, userId, *scrobbler, clusterIds, range);
+        res = Database::Listen::getTopTracks(session, userId, *backend, clusterIds, range);
         return res;
     }
-
-    void ScrobblingService::star(UserId userId, ArtistId artistId)
-    {
-        star<Artist, ArtistId, StarredArtist>(userId, artistId);
-    }
-
-    void ScrobblingService::unstar(UserId userId, ArtistId artistId)
-    {
-        unstar<Artist, ArtistId, StarredArtist>(userId, artistId);
-    }
-
-    bool ScrobblingService::isStarred(UserId userId, ArtistId artistId)
-    {
-        return isStarred<Artist, ArtistId, StarredArtist>(userId, artistId);
-    }
-
-    Wt::WDateTime ScrobblingService::getStarredDateTime(UserId userId, ArtistId artistId)
-    {
-        return getStarredDateTime<Artist, ArtistId, StarredArtist>(userId, artistId);
-    }
-
-    ScrobblingService::ArtistContainer ScrobblingService::getStarredArtists(UserId userId, const std::vector<ClusterId>& clusterIds,
-        std::optional<TrackArtistLinkType> linkType,
-        ArtistSortMethod sortMethod,
-        Range range)
-    {
-        auto scrobbler{ getUserScrobbler(userId) };
-        if (!scrobbler)
-            return {};
-
-        Artist::FindParameters params;
-        params.setStarringUser(userId, *scrobbler);
-        params.setClusters(clusterIds);
-        params.setLinkType(linkType);
-        params.setSortMethod(sortMethod);
-        params.setRange(range);
-
-        Session& session{ _db.getTLSSession() };
-        auto transaction{ session.createSharedTransaction() };
-
-        return Artist::find(session, params);
-    }
-
-    void ScrobblingService::star(UserId userId, ReleaseId releaseId)
-    {
-        star<Release, ReleaseId, StarredRelease>(userId, releaseId);
-    }
-
-    void ScrobblingService::unstar(UserId userId, ReleaseId releaseId)
-    {
-        unstar<Release, ReleaseId, StarredRelease>(userId, releaseId);
-    }
-
-    bool ScrobblingService::isStarred(UserId userId, ReleaseId releaseId)
-    {
-        return isStarred<Release, ReleaseId, StarredRelease>(userId, releaseId);
-    }
-
-    Wt::WDateTime ScrobblingService::getStarredDateTime(UserId userId, ReleaseId releaseId)
-    {
-        return getStarredDateTime<Release, ReleaseId, StarredRelease>(userId, releaseId);
-    }
-
-    ScrobblingService::ReleaseContainer ScrobblingService::getStarredReleases(UserId userId, const std::vector<ClusterId>& clusterIds, Range range)
-    {
-        auto scrobbler{ getUserScrobbler(userId) };
-        if (!scrobbler)
-            return {};
-
-        Release::FindParameters params;
-        params.setStarringUser(userId, *scrobbler);
-        params.setClusters(clusterIds);
-        params.setSortMethod(ReleaseSortMethod::StarredDateDesc);
-        params.setRange(range);
-
-        Session& session{ _db.getTLSSession() };
-        auto transaction{ session.createSharedTransaction() };
-
-        return Release::find(session, params);
-    }
-
-    void ScrobblingService::star(UserId userId, TrackId trackId)
-    {
-        star<Track, TrackId, StarredTrack>(userId, trackId);
-    }
-
-    void ScrobblingService::unstar(UserId userId, TrackId trackId)
-    {
-        unstar<Track, TrackId, StarredTrack>(userId, trackId);
-    }
-
-    bool ScrobblingService::isStarred(UserId userId, TrackId trackId)
-    {
-        return isStarred<Track, TrackId, StarredTrack>(userId, trackId);
-    }
-
-    Wt::WDateTime ScrobblingService::getStarredDateTime(UserId userId, TrackId trackId)
-    {
-        return getStarredDateTime<Track, TrackId, StarredTrack>(userId, trackId);
-    }
-
-    ScrobblingService::TrackContainer ScrobblingService::getStarredTracks(UserId userId, const std::vector<ClusterId>& clusterIds, Range range)
-    {
-        auto scrobbler{ getUserScrobbler(userId) };
-        if (!scrobbler)
-            return {};
-
-        Track::FindParameters params;
-        params.setStarringUser(userId, *scrobbler);
-        params.setClusters(clusterIds);
-        params.setSortMethod(TrackSortMethod::StarredDateDesc);
-        params.setRange(range);
-
-        Session& session{ _db.getTLSSession() };
-        auto transaction{ session.createSharedTransaction() };
-
-        return Track::find(session, params);
-    }
 } // ns Scrobbling
 
diff --git a/src/libs/services/scrobbling/impl/ScrobblingService.hpp b/src/libs/services/scrobbling/impl/ScrobblingService.hpp
index 68cc27ec..53926120 100644
--- a/src/libs/services/scrobbling/impl/ScrobblingService.hpp
+++ b/src/libs/services/scrobbling/impl/ScrobblingService.hpp
@@ -24,7 +24,7 @@
 #include <unordered_map>
 
 #include "services/scrobbling/IScrobblingService.hpp"
-#include "IScrobbler.hpp"
+#include "IScrobblingBackend.hpp"
 
 namespace Scrobbling
 {
@@ -39,70 +39,21 @@ namespace Scrobbling
         void listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration) override;
         void addTimedListen(const TimedListen& listen) override;
 
-        ArtistContainer getRecentArtists(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            std::optional<Database::TrackArtistLinkType> linkType,
-            Database::Range range) override;
-
-        ReleaseContainer getRecentReleases(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            Database::Range range) override;
-
-        TrackContainer getRecentTracks(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            Database::Range range) override;
+        ArtistContainer getRecentArtists(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, std::optional<Database::TrackArtistLinkType> linkType,Database::Range range) override;
+        ReleaseContainer getRecentReleases(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds,Database::Range range) override;
+        TrackContainer getRecentTracks(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) override;
 
         Wt::WDateTime getLastListenDateTime(Database::UserId userId, Database::ReleaseId releaseId) override;
         Wt::WDateTime getLastListenDateTime(Database::UserId userId, Database::TrackId trackId) override;
 
-        ArtistContainer getTopArtists(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            std::optional<Database::TrackArtistLinkType> linkType,
-            Database::Range range) override;
+        ArtistContainer getTopArtists(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, std::optional<Database::TrackArtistLinkType> linkType, Database::Range range) override;
+        ReleaseContainer getTopReleases(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) override;
+        TrackContainer getTopTracks(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) override;
 
-        ReleaseContainer getTopReleases(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            Database::Range range) override;
-
-        TrackContainer getTopTracks(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            Database::Range range) override;
-
-        void star(Database::UserId userId, Database::ArtistId artistId) override;
-        void unstar(Database::UserId userId, Database::ArtistId artistId) override;
-        bool isStarred(Database::UserId userId, Database::ArtistId artistId) override;
-        Wt::WDateTime getStarredDateTime(Database::UserId userId, Database::ArtistId artistId) override;
-        ArtistContainer	getStarredArtists(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            std::optional<Database::TrackArtistLinkType> linkType,
-            Database::ArtistSortMethod sortMethod,
-            Database::Range range) override;
-
-        void star(Database::UserId userId, Database::ReleaseId releaseId) override;
-        void unstar(Database::UserId userId, Database::ReleaseId releaseId) override;
-        bool isStarred(Database::UserId userId, Database::ReleaseId releasedId) override;
-        Wt::WDateTime getStarredDateTime(Database::UserId userId, Database::ReleaseId releasedId) override;
-        ReleaseContainer getStarredReleases(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) override;
-
-        void star(Database::UserId userId, Database::TrackId trackId) override;
-        void unstar(Database::UserId userId, Database::TrackId trackId) override;
-        bool isStarred(Database::UserId userId, Database::TrackId trackId) override;
-        Wt::WDateTime getStarredDateTime(Database::UserId userId, Database::TrackId trackId) override;
-        TrackContainer getStarredTracks(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) override;
-
-        std::optional<Database::Scrobbler> getUserScrobbler(Database::UserId userId);
-
-        template <typename ObjType, typename ObjIdType, typename StarredObjType>
-        void star(Database::UserId userId, ObjIdType id);
-        template <typename ObjType, typename ObjIdType, typename StarredObjType>
-        void unstar(Database::UserId userId, ObjIdType id);
-        template <typename ObjType, typename ObjIdType, typename StarredObjType>
-        bool isStarred(Database::UserId userId, ObjIdType id);
-        template <typename ObjType, typename ObjIdType, typename StarredObjType>
-        Wt::WDateTime getStarredDateTime(Database::UserId userId, ObjIdType id);
+        std::optional<Database::ScrobblingBackend> getUserBackend(Database::UserId userId);
 
         Database::Db& _db;
-        std::unordered_map<Database::Scrobbler, std::unique_ptr<IScrobbler>> _scrobblers;
+        std::unordered_map<Database::ScrobblingBackend, std::unique_ptr<IScrobblingBackend>> _scrobblingBackends;
     };
 
 } // ns Scrobbling
diff --git a/src/libs/services/scrobbling/impl/ScrobblingService.impl.hpp b/src/libs/services/scrobbling/impl/ScrobblingService.impl.hpp
deleted file mode 100644
index bf26979b..00000000
--- a/src/libs/services/scrobbling/impl/ScrobblingService.impl.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (C) 2021 Emeric Poupon
- *
- * This file is part of LMS.
- *
- * LMS is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * LMS 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include "services/database/Db.hpp"
-#include "services/database/Session.hpp"
-#include "services/database/User.hpp"
-
-namespace Scrobbling
-{
-    using namespace Database;
-
-    template <typename ObjType, typename ObjIdType, typename StarredObjType>
-    void ScrobblingService::star(UserId userId, ObjIdType objId)
-    {
-        auto scrobbler {getUserScrobbler(userId)};
-        if (!scrobbler)
-            return;
-
-        typename StarredObjType::IdType starredObjId;
-        {
-            Session& session {_db.getTLSSession()};
-            auto transaction {session.createUniqueTransaction()};
-
-            typename StarredObjType::pointer starredObj {StarredObjType::find(session, objId, userId, *scrobbler)};
-            if (!starredObj)
-            {
-                const typename ObjType::pointer obj {ObjType::find(session, objId)};
-                if (!obj)
-                    return;
-
-                const User::pointer user {User::find(session, userId)};
-                if (!user)
-                    return;
-
-                starredObj = session.create<StarredObjType>(obj, user, *scrobbler);
-            }
-            starredObj.modify()->setDateTime(Wt::WDateTime::currentDateTime());
-            starredObjId = starredObj->getId();
-        }
-        _scrobblers[*scrobbler]->onStarred(starredObjId);
-    }
-
-    template <typename ObjType, typename ObjIdType, typename StarredObjType>
-    void ScrobblingService::unstar(UserId userId, ObjIdType objId)
-    {
-        auto scrobbler {getUserScrobbler(userId)};
-        if (!scrobbler)
-            return;
-
-        typename StarredObjType::IdType starredObjId;
-        {
-            Session& session {_db.getTLSSession()};
-            auto transaction {session.createSharedTransaction()};
-
-            typename StarredObjType::pointer starredObj {StarredObjType::find(session, objId, userId, *scrobbler)};
-            if (!starredObj)
-                return;
-
-            starredObjId = starredObj->getId();
-        }
-        _scrobblers[*scrobbler]->onUnstarred(starredObjId);
-    }
-
-    template <typename ObjType, typename ObjIdType, typename StarredObjType>
-    bool ScrobblingService::isStarred(UserId userId, ObjIdType objId)
-    {
-        auto scrobbler {getUserScrobbler(userId)};
-        if (!scrobbler)
-            return false;
-
-        Session& session {_db.getTLSSession()};
-        auto transaction {session.createSharedTransaction()};
-
-        typename StarredObjType::pointer starredObj {StarredObjType::find(session, objId, userId, *scrobbler)};
-        return starredObj && (starredObj->getScrobblingState() != ScrobblingState::PendingRemove);
-    }
-
-    template <typename ObjType, typename ObjIdType, typename StarredObjType>
-    Wt::WDateTime ScrobblingService::getStarredDateTime(UserId userId, ObjIdType objId)
-    {
-        auto scrobbler {getUserScrobbler(userId)};
-        if (!scrobbler)
-            return {};
-
-        Session& session {_db.getTLSSession()};
-        auto transaction {session.createSharedTransaction()};
-
-        typename StarredObjType::pointer starredObj {StarredObjType::find(session, objId, userId, *scrobbler)};
-        if (starredObj && (starredObj->getScrobblingState() != ScrobblingState::PendingRemove))
-            return starredObj->getDateTime();
-
-        return {};
-    }
-
-} // ns Scrobbling
-
diff --git a/src/libs/services/scrobbling/impl/internal/InternalBackend.cpp b/src/libs/services/scrobbling/impl/internal/InternalBackend.cpp
new file mode 100644
index 00000000..78c4353d
--- /dev/null
+++ b/src/libs/services/scrobbling/impl/internal/InternalBackend.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2021 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "InternalBackend.hpp"
+
+#include "services/database/Db.hpp"
+#include "services/database/Listen.hpp"
+#include "services/database/Session.hpp"
+#include "services/database/Track.hpp"
+#include "services/database/User.hpp"
+
+namespace Scrobbling
+{
+    InternalBackend::InternalBackend(Database::Db& db)
+        : _db{ db }
+    {}
+
+    void InternalBackend::listenStarted(const Listen&)
+    {
+        // nothing to do
+    }
+
+    void InternalBackend::listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration)
+    {
+        // only record tracks that have been played for at least of few seconds...
+        if (duration && *duration < std::chrono::seconds{ 5 })
+            return;
+
+        addTimedListen({ listen, Wt::WDateTime::currentDateTime() });
+    }
+
+    void InternalBackend::addTimedListen(const TimedListen& listen)
+    {
+        Database::Session& session{ _db.getTLSSession() };
+        auto transaction{ session.createUniqueTransaction() };
+
+        if (Database::Listen::find(session, listen.userId, listen.trackId, Database::ScrobblingBackend::Internal, listen.listenedAt))
+            return;
+
+        const Database::User::pointer user{ Database::User::find(session, listen.userId) };
+        if (!user)
+            return;
+
+        const Database::Track::pointer track{ Database::Track::find(session, listen.trackId) };
+        if (!track)
+            return;
+
+        auto dbListen{ session.create<Database::Listen>(user, track, Database::ScrobblingBackend::Internal, listen.listenedAt) };
+        dbListen.modify()->setSyncState(Database::SyncState::Synchronized);
+    }
+} // Scrobbling
+
diff --git a/src/libs/services/scrobbling/impl/internal/InternalBackend.hpp b/src/libs/services/scrobbling/impl/internal/InternalBackend.hpp
new file mode 100644
index 00000000..bd3a3c17
--- /dev/null
+++ b/src/libs/services/scrobbling/impl/internal/InternalBackend.hpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2021 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "IScrobblingBackend.hpp"
+
+namespace Database
+{
+    class Db;
+}
+
+namespace Scrobbling
+{
+    class InternalBackend final : public IScrobblingBackend
+    {
+    public:
+        InternalBackend(Database::Db& db);
+
+    private:
+        void listenStarted(const Listen& listen) override;
+        void listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration) override;
+        void addTimedListen(const TimedListen& listen) override;
+
+        Database::Db& _db;
+    };
+} // Scrobbling
+
diff --git a/src/libs/services/scrobbling/impl/internal/InternalScrobbler.cpp b/src/libs/services/scrobbling/impl/internal/InternalScrobbler.cpp
deleted file mode 100644
index 02c9ed1c..00000000
--- a/src/libs/services/scrobbling/impl/internal/InternalScrobbler.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (C) 2021 Emeric Poupon
- *
- * This file is part of LMS.
- *
- * LMS is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * LMS 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "InternalScrobbler.hpp"
-
-#include "services/database/Db.hpp"
-#include "services/database/Listen.hpp"
-#include "services/database/Session.hpp"
-#include "services/database/StarredArtist.hpp"
-#include "services/database/StarredRelease.hpp"
-#include "services/database/StarredTrack.hpp"
-#include "services/database/Track.hpp"
-#include "services/database/User.hpp"
-
-namespace
-{
-    template <typename StarredObjType>
-    void onStarred(Database::Session& session, typename StarredObjType::IdType id)
-    {
-        auto transaction{ session.createUniqueTransaction() };
-
-        if (auto starredObj{ StarredObjType::find(session, id) })
-            starredObj.modify()->setScrobblingState(Database::ScrobblingState::Synchronized);
-    }
-
-    template <typename StarredObjType>
-    void onUnstarred(Database::Session& session, typename StarredObjType::IdType id)
-    {
-        auto transaction{ session.createUniqueTransaction() };
-
-        if (auto starredObj{ StarredObjType::find(session, id) })
-            starredObj.remove();
-    }
-}
-
-namespace Scrobbling
-{
-    InternalScrobbler::InternalScrobbler(Database::Db& db)
-        : _db{ db }
-    {}
-
-    void InternalScrobbler::listenStarted(const Listen&)
-    {
-        // nothing to do
-    }
-
-    void InternalScrobbler::listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration)
-    {
-        // only record tracks that have been played for at least of few seconds...
-        if (duration && *duration < std::chrono::seconds{ 5 })
-            return;
-
-        addTimedListen({ listen, Wt::WDateTime::currentDateTime() });
-    }
-
-    void InternalScrobbler::addTimedListen(const TimedListen& listen)
-    {
-        Database::Session& session{ _db.getTLSSession() };
-        auto transaction{ session.createUniqueTransaction() };
-
-        if (Database::Listen::find(session, listen.userId, listen.trackId, Database::Scrobbler::Internal, listen.listenedAt))
-            return;
-
-        const Database::User::pointer user{ Database::User::find(session, listen.userId) };
-        if (!user)
-            return;
-
-        const Database::Track::pointer track{ Database::Track::find(session, listen.trackId) };
-        if (!track)
-            return;
-
-        auto dbListen{ session.create<Database::Listen>(user, track, Database::Scrobbler::Internal, listen.listenedAt) };
-        dbListen.modify()->setScrobblingState(Database::ScrobblingState::Synchronized);
-    }
-
-    void InternalScrobbler::onStarred(Database::StarredArtistId starredArtistId)
-    {
-        ::onStarred<Database::StarredArtist>(_db.getTLSSession(), starredArtistId);
-    }
-
-    void InternalScrobbler::onUnstarred(Database::StarredArtistId starredArtistId)
-    {
-        ::onUnstarred<Database::StarredArtist>(_db.getTLSSession(), starredArtistId);
-    }
-
-    void InternalScrobbler::onStarred(Database::StarredReleaseId starredReleaseId)
-    {
-        ::onStarred<Database::StarredRelease>(_db.getTLSSession(), starredReleaseId);
-    }
-
-    void InternalScrobbler::onUnstarred(Database::StarredReleaseId starredReleaseId)
-    {
-        ::onUnstarred<Database::StarredRelease>(_db.getTLSSession(), starredReleaseId);
-    }
-
-    void InternalScrobbler::onStarred(Database::StarredTrackId starredTrackId)
-    {
-        ::onStarred<Database::StarredTrack>(_db.getTLSSession(), starredTrackId);
-    }
-
-    void InternalScrobbler::onUnstarred(Database::StarredTrackId starredTrackId)
-    {
-        ::onUnstarred<Database::StarredTrack>(_db.getTLSSession(), starredTrackId);
-    }
-} // Scrobbling
-
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/FeedbacksParser.cpp b/src/libs/services/scrobbling/impl/listenbrainz/FeedbacksParser.cpp
deleted file mode 100644
index e3ace6cb..00000000
--- a/src/libs/services/scrobbling/impl/listenbrainz/FeedbacksParser.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright (C) 2022 Emeric Poupon
- *
- * This file is part of LMS.
- *
- * LMS is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * LMS 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "FeedbacksParser.hpp"
-
-#include <Wt/Json/Array.h>
-#include <Wt/Json/Object.h>
-#include <Wt/Json/Value.h>
-#include <Wt/Json/Parser.h>
-
-#include "services/scrobbling/Exception.hpp"
-#include "Exception.hpp"
-#include "Utils.hpp"
-
-namespace Scrobbling::ListenBrainz
-{
-	namespace
-	{
-		Feedback
-		parseFeedback(const Wt::Json::Object& feedbackObj)
-		{
-			const std::optional<UUID> recordingMBID {UUID::fromString(static_cast<std::string>(feedbackObj.get("recording_mbid")))};
-			if (!recordingMBID)
-				throw Exception {"MBID not found!"};
-
-			return Feedback
-			{
-				Wt::WDateTime::fromTime_t(static_cast<int>(feedbackObj.get("created"))),
-					*recordingMBID,
-					static_cast<FeedbackType>(static_cast<int>(feedbackObj.get("score")))
-			};
-		}
-	}
-
-	FeedbacksParser::Result
-	FeedbacksParser::parse(std::string_view msgBody)
-	{
-		Result res;
-
-		try
-		{
-			Wt::Json::Object root;
-			Wt::Json::parse(std::string {msgBody}, root);
-
-			const Wt::Json::Array& feedbacks = root.get("feedback");
-
-			LOG(DEBUG) << "Got " << feedbacks.size() << " feedbacks";
-
-			if (feedbacks.empty())
-				return res;
-
-			res.feedbackCount = feedbacks.size();
-
-			for (const Wt::Json::Value& value : feedbacks)
-			{
-				try
-				{
-					res.feedbacks.push_back(parseFeedback(value));
-				}
-				catch (const Exception& e)
-				{
-					LOG(DEBUG) << "Cannot parse feedback: " << e.what() << ", skipping";
-				}
-				catch (const Wt::WException &e)
-				{
-					LOG(DEBUG) << "Cannot parse feedback: " << e.what() << ", skipping";
-				}
-			}
-		}
-		catch (const Wt::WException& error)
-		{
-			LOG(ERROR) << "Cannot parse 'feedback' result: " << error.what();
-		}
-
-		return res;
-	}
-} // Scrobbling::ListenBrainz
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/FeedbacksSynchronizer.cpp b/src/libs/services/scrobbling/impl/listenbrainz/FeedbacksSynchronizer.cpp
deleted file mode 100644
index e9265122..00000000
--- a/src/libs/services/scrobbling/impl/listenbrainz/FeedbacksSynchronizer.cpp
+++ /dev/null
@@ -1,505 +0,0 @@
-/*
- * Copyright (C) 2021 Emeric Poupon
- *
- * This file is part of LMS.
- *
- * LMS is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * LMS 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "ListenBrainzScrobbler.hpp"
-
-#include <tuple>
-#include <boost/asio/bind_executor.hpp>
-#include <Wt/Json/Array.h>
-#include <Wt/Json/Object.h>
-#include <Wt/Json/Value.h>
-#include <Wt/Json/Serializer.h>
-
-#include "services/database/Db.hpp"
-#include "services/database/Session.hpp"
-#include "services/database/StarredTrack.hpp"
-#include "services/database/Track.hpp"
-#include "services/database/User.hpp"
-#include "utils/IConfig.hpp"
-#include "utils/http/IClient.hpp"
-#include "utils/Service.hpp"
-
-#include "Exception.hpp"
-#include "FeedbacksParser.hpp"
-#include "Utils.hpp"
-
-using namespace Scrobbling::ListenBrainz;
-using namespace Database;
-
-namespace
-{
-	std::optional<std::size_t>
-	parseTotalFeedbackCount(std::string_view msgBody)
-	{
-		try
-		{
-			Wt::Json::Object root;
-			Wt::Json::parse(std::string {msgBody}, root);
-
-			return static_cast<int>(root.get("total_count"));
-		}
-		catch (const Wt::WException& e)
-		{
-			LOG(ERROR) << "Cannot parse listen count response: " << e.what();
-			return std::nullopt;
-		}
-	}
-}
-
-namespace Scrobbling::ListenBrainz
-{
-	FeedbacksSynchronizer::FeedbacksSynchronizer(boost::asio::io_context& ioContext, Database::Db& db, Http::IClient& client)
-		: _ioContext {ioContext}
-		, _db {db}
-		, _client {client}
-		, _maxSyncFeedbackCount {Service<IConfig>::get()->getULong("listenbrainz-max-sync-feedback-count", 1000)}
-		, _syncFeedbacksPeriod {Service<IConfig>::get()->getULong("listenbrainz-sync-feedbacks-period-hours", 1)}
-	{
-		LOG(INFO) << "Starting Feedbacks synchronizer, maxSyncFeedbackCount = " << _maxSyncFeedbackCount << ", _syncFeedbacksPeriod = " << _syncFeedbacksPeriod.count() << " hours";
-
-		scheduleSync(std::chrono::seconds {30});
-	}
-
-	void
-	FeedbacksSynchronizer::enqueFeedback(FeedbackType type, Database::StarredTrackId starredTrackId)
-	{
-		try
-		{
-			Database::Session& session {_db.getTLSSession()};
-
-			auto transaction {session.createUniqueTransaction()};
-
-			StarredTrack::pointer starredTrack {StarredTrack::find(session, starredTrackId)};
-			if (!starredTrack)
-				return;
-
-			std::optional<UUID> recordingMBID {starredTrack->getTrack()->getRecordingMBID()};
-
-			switch (type)
-			{
-				case FeedbackType::Love:
-					if (starredTrack->getScrobblingState() != ScrobblingState::PendingAdd)
-						starredTrack.modify()->setScrobblingState(ScrobblingState::PendingAdd);
-					break;
-
-				case FeedbackType::Erase:
-					if (!recordingMBID)
-					{
-						LOG(DEBUG) << "Track has no recording MBID: erasing star";
-						starredTrack.remove();
-					}
-					else
-					{
-						// Send the erase order even if it is not on the remote LB server (it may be
-						// queued for add, or not)
-						starredTrack.modify()->setScrobblingState(ScrobblingState::PendingRemove);
-					}
-					break;
-
-				default:
-					throw Exception {"Unhandled feedback type"};
-			}
-
-			if (!recordingMBID)
-			{
-				LOG(DEBUG) << "Track has no recording MBID: skipping";
-				return;
-			}
-
-			const std::optional<UUID> listenBrainzToken {starredTrack->getUser()->getListenBrainzToken()};
-			if (!listenBrainzToken)
-				return;
-
-			Http::ClientPOSTRequestParameters request;
-			request.relativeUrl = "/1/feedback/recording-feedback";
-			request.message.addHeader("Authorization", "Token " + std::string {listenBrainzToken->getAsString()});
-
-			Wt::Json::Object root;
-			root["recording_mbid"] = Wt::Json::Value {std::string {recordingMBID->getAsString()}};
-			root["score"] = Wt::Json::Value {static_cast<int>(type)};
-
-			request.message.addBodyText(Wt::Json::serialize(root));
-			request.message.addHeader("Content-Type", "application/json");
-
-			request.onSuccessFunc = [=](std::string_view /*msgBody*/)
-			{
-				_strand.dispatch([=]
-				{
-					onFeedbackSent(type, starredTrackId);
-				});
-			};
-			_client.sendPOSTRequest(std::move(request));
-		}
-		catch (Exception& e)
-		{
-			LOG(DEBUG) << "Cannot send feedback: " << e.what();
-		}
-	}
-
-	void
-	FeedbacksSynchronizer::onFeedbackSent(FeedbackType type, Database::StarredTrackId starredTrackId)
-	{
-		assert(_strand.running_in_this_thread());
-
-		Session& session {_db.getTLSSession()};
-		auto transaction {session.createUniqueTransaction()};
-
-		StarredTrack::pointer starredTrack {StarredTrack::find(session, starredTrackId)};
-		if (!starredTrack)
-		{
-			LOG(DEBUG) << "Starred track not found. deleted?";
-			return;
-		}
-
-		UserContext& userContext {getUserContext(starredTrack->getUser()->getId())};
-
-		switch (type)
-		{
-			case FeedbackType::Love:
-				starredTrack.modify()->setScrobblingState(ScrobblingState::Synchronized);
-				LOG(DEBUG) << "State set to synchronized";
-
-				if (userContext.feedbackCount)
-				{
-					(*userContext.feedbackCount)++;
-					LOG(DEBUG) << "Feedback count set to " << *userContext.feedbackCount << " for user '" << userContext.listenBrainzUserName <<"'";
-				}
-				break;
-
-			case FeedbackType::Erase:
-				starredTrack.remove();
-				LOG(DEBUG) << "Removed starred track";
-
-				if (userContext.feedbackCount && *userContext.feedbackCount > 0)
-				{
-					(*userContext.feedbackCount)--;
-					LOG(DEBUG) << "Feedback count set to " << *userContext.feedbackCount << " for user '" << userContext.listenBrainzUserName <<"'";
-				}
-				break;
-
-			default:
-				throw Exception {"Unhandled feedback type"};
-		}
-	}
-
-	void
-	FeedbacksSynchronizer::enquePendingFeedbacks()
-	{
-		auto processPendingFeedbacks { [this] (ScrobblingState scrobblingState, FeedbackType feedbackType)
-		{
-			RangeResults<StarredTrackId> pendingFeedbacks;
-
-			{
-				Database::Session& session {_db.getTLSSession()};
-
-				auto transaction {session.createSharedTransaction()};
-
-				StarredTrack::FindParameters params;
-				params.setScrobbler(Database::Scrobbler::ListenBrainz, scrobblingState)
-						.setRange(Database::Range {0, 100}); // don't flood too much?
-
-				pendingFeedbacks = StarredTrack::find(session, params);
-			}
-
-			LOG(DEBUG) << "Queing " << pendingFeedbacks.results.size() << " pending '" << (feedbackType == FeedbackType::Love ? "love" : "erase") << "' feedbacks";
-
-			for (const StarredTrackId starredTrackId : pendingFeedbacks.results)
-				enqueFeedback(feedbackType, starredTrackId);
-		}};
-
-		processPendingFeedbacks(ScrobblingState::PendingAdd, FeedbackType::Love);
-		processPendingFeedbacks(ScrobblingState::PendingRemove, FeedbackType::Erase);
-	}
-
-	FeedbacksSynchronizer::UserContext&
-	FeedbacksSynchronizer::getUserContext(Database::UserId userId)
-	{
-		assert(_strand.running_in_this_thread());
-
-		auto itContext {_userContexts.find(userId)};
-		if (itContext == std::cend(_userContexts))
-		{
-			std::tie(itContext, std::ignore) = _userContexts.emplace(userId, userId);
-		}
-
-		return itContext->second;
-	}
-
-	bool
-	FeedbacksSynchronizer::isSyncing() const
-	{
-		return std::any_of(std::cbegin(_userContexts), std::cend(_userContexts), [](const auto& contextEntry)
-				{
-					return contextEntry.second.syncing;
-				});
-	}
-
-	void
-	FeedbacksSynchronizer::scheduleSync(std::chrono::seconds fromNow)
-	{
-		if (_syncFeedbacksPeriod.count() == 0 || _maxSyncFeedbackCount == 0)
-			return;
-
-		LOG(DEBUG) << "Scheduled sync in " << fromNow.count() << " seconds...";
-		_syncTimer.expires_after(fromNow);
-		_syncTimer.async_wait(boost::asio::bind_executor(_strand, [this] (const boost::system::error_code& ec)
-		{
-			if (ec == boost::asio::error::operation_aborted)
-			{
-				LOG(DEBUG) << "getFeedbacks aborted";
-				return;
-			}
-			else if (ec)
-			{
-				throw Exception {"GetFeedbacks timer failure: " + std::string {ec.message()} };
-			}
-
-			startSync();
-		}));
-	}
-
-	void
-	FeedbacksSynchronizer::startSync()
-	{
-		LOG(DEBUG) << "Starting sync!";
-
-		assert(!isSyncing());
-		assert(_strand.running_in_this_thread());
-
-		enquePendingFeedbacks();
-
-		Database::RangeResults<Database::UserId> userIds;
-		{
-			Database::Session& session {_db.getTLSSession()};
-			auto transaction {session.createSharedTransaction()};
-			userIds = Database::User::find(_db.getTLSSession(), Database::User::FindParameters{}.setScrobbler(Database::Scrobbler::ListenBrainz));
-		}
-
-		for (const Database::UserId userId : userIds.results)
-			startSync(getUserContext(userId));
-
-		if (!isSyncing())
-			scheduleSync(_syncFeedbacksPeriod);
-	}
-
-	void
-	FeedbacksSynchronizer::startSync(UserContext& context)
-	{
-		context.syncing = true;
-		context.listenBrainzUserName = "";
-		context.fetchedFeedbackCount = 0;
-		context.matchedFeedbackCount = 0;
-		context.importedFeedbackCount = 0;
-
-		enqueValidateToken(context);
-	}
-
-	void
-	FeedbacksSynchronizer::onSyncEnded(UserContext& context)
-	{
-		_strand.dispatch([this, &context]
-		{
-			LOG(INFO) << "Feedback sync done for user '" << context.listenBrainzUserName << "', fetched: " << context.fetchedFeedbackCount << ", matched: " << context.matchedFeedbackCount << ", imported: " << context.importedFeedbackCount;
-			context.syncing = false;
-
-			if (!isSyncing())
-				scheduleSync(_syncFeedbacksPeriod);
-		});
-	}
-
-	void
-	FeedbacksSynchronizer::enqueValidateToken(UserContext& context)
-	{
-		assert(context.listenBrainzUserName.empty());
-
-		const std::optional<UUID> listenBrainzToken {Utils::getListenBrainzToken(_db.getTLSSession(), context.userId)};
-		if (!listenBrainzToken)
-		{
-			onSyncEnded(context);
-			return;
-		}
-
-		Http::ClientGETRequestParameters request;
-		request.priority = Http::ClientRequestParameters::Priority::Low;
-		request.relativeUrl = "/1/validate-token";
-		request.headers = { {"Authorization",  "Token " + std::string {listenBrainzToken->getAsString()}} };
-		request.onSuccessFunc = [this, &context] (std::string_view msgBody)
-			{
-				context.listenBrainzUserName = Utils::parseValidateToken(msgBody);
-				if (context.listenBrainzUserName.empty())
-				{
-					onSyncEnded(context);
-					return;
-				}
-				enqueGetFeedbackCount(context);
-			};
-		request.onFailureFunc = [this, &context]
-			{
-				onSyncEnded(context);
-			};
-
-		_client.sendGETRequest(std::move(request));
-	}
-
-	void
-	FeedbacksSynchronizer::enqueGetFeedbackCount(UserContext& context)
-	{
-		assert(!context.listenBrainzUserName.empty());
-
-		Http::ClientGETRequestParameters request;
-		request.relativeUrl = "/1/feedback/user/" + std::string {context.listenBrainzUserName} + "/get-feedback?score=1&count=0";
-		request.priority = Http::ClientRequestParameters::Priority::Low;
-		request.onSuccessFunc = [this, &context] (std::string_view msgBody)
-			{
-				std::string msgBodyCopy {msgBody};
-				_strand.dispatch([this, msgBodyCopy, &context]
-				{
-					LOG(DEBUG) << "Current feedback count = " << (context.feedbackCount ? *context.feedbackCount : 0) << " for user '" << context.listenBrainzUserName << "'";
-
-					const auto totalFeedbackCount = parseTotalFeedbackCount(msgBodyCopy);
-					if (totalFeedbackCount)
-						LOG(DEBUG) << "Feedback count for listenbrainz user '" << context.listenBrainzUserName << "' = " << *totalFeedbackCount;
-
-					bool needSync {totalFeedbackCount && (!context.feedbackCount || *context.feedbackCount != *totalFeedbackCount)};
-					context.feedbackCount = totalFeedbackCount;
-
-					if (needSync)
-						enqueGetFeedbacks(context);
-					else
-						onSyncEnded(context);
-				});
-			};
-		request.onFailureFunc = [this, &context]
-			{
-				onSyncEnded(context);
-			};
-
-		_client.sendGETRequest(std::move(request));
-	}
-
-	void
-	FeedbacksSynchronizer::enqueGetFeedbacks(UserContext& context)
-	{
-		assert(!context.listenBrainzUserName.empty());
-
-		Http::ClientGETRequestParameters request;
-		request.relativeUrl = "/1/feedback/user/" + context.listenBrainzUserName + "/get-feedback?offset=" + std::to_string(context.fetchedFeedbackCount);
-		request.priority = Http::ClientRequestParameters::Priority::Low;
-		request.onSuccessFunc = [this, &context] (std::string_view msgBody)
-			{
-				std::string msgBodyCopy {msgBody};
-				_strand.dispatch([this, msgBodyCopy, &context]
-				{
-					const std::size_t fetchedFeedbackCount {processGetFeedbacks(msgBodyCopy, context)};
-					if (fetchedFeedbackCount == 0 // no more thing available on server
-							|| context.fetchedFeedbackCount >= context.feedbackCount // we may miss something, but we will get it next time
-							|| context.fetchedFeedbackCount >= _maxSyncFeedbackCount)
-					{
-						onSyncEnded(context);
-					}
-					else
-					{
-						enqueGetFeedbacks(context);
-					}
-				});
-			};
-		request.onFailureFunc = [=, &context]
-			{
-				onSyncEnded(context);
-			};
-
-		_client.sendGETRequest(std::move(request));
-	}
-
-	std::size_t
-	FeedbacksSynchronizer::processGetFeedbacks(std::string_view msgBody, UserContext& context)
-	{
-		const FeedbacksParser::Result parseResult {FeedbacksParser::parse(msgBody)};
-
-		LOG(DEBUG) << "Parsed " << parseResult.feedbackCount << " feedbacks, found " << parseResult.feedbacks.size() << " usable entries";
-		context.fetchedFeedbackCount += parseResult.feedbackCount;
-
-		for (const Feedback& feedback : parseResult.feedbacks)
-		{
-			tryImportFeedback(feedback, context);
-		}
-
-		return parseResult.feedbackCount;
-	}
-
-	void
-	FeedbacksSynchronizer::tryImportFeedback(const Feedback& feedback, UserContext& context)
-	{
-		Database::Session& session {_db.getTLSSession()};
-
-		bool needImport{};
-		TrackId trackId;
-
-		{
-			auto transaction {session.createSharedTransaction()};
-			const std::vector<Track::pointer> tracks {Track::findByRecordingMBID(session, feedback.recordingMBID)};
-			if (tracks.size() > 1)
-			{
-				LOG(DEBUG) << "Too many matches for feedback '" << feedback << "': duplicate recording MBIDs found";
-				return;
-			}
-			else if (tracks.empty())
-			{
-				LOG(DEBUG) << "Cannot match feedback '" << feedback << "': no track found for this recording MBID";
-				return;
-			}
-
-			trackId = tracks.front()->getId();
-
-			const StarredTrack::pointer starredTrack {StarredTrack::find(session, trackId, context.userId, Database::Scrobbler::ListenBrainz)};
-			needImport = !starredTrack;
-
-			// don't update starred date time
-			// no need to update state if it was found as not synchronized
-			// pending remove => will be removed later
-			// pending add => will be resent later
-		}
-
-		if (needImport)
-		{
-			LOG(DEBUG) << "Importing feedback '" << feedback << "'";
-
-			auto transaction {session.createUniqueTransaction()};
-
-			const Track::pointer track {Track::find(session, trackId)};
-			if (!track)
-				return;
-
-			const User::pointer user {User::find(session, context.userId)};
-			if (!user)
-				return;
-
-			StarredTrack::pointer starredTrack {session.create<StarredTrack>(track, user, Database::Scrobbler::ListenBrainz)};
-			starredTrack.modify()->setScrobblingState(ScrobblingState::Synchronized);
-			starredTrack.modify()->setDateTime(feedback.created);
-
-			context.importedFeedbackCount++;
-		}
-		else
-		{
-			LOG(DEBUG) << "No need to import feedback '" << feedback << "', already imported";
-			context.matchedFeedbackCount++;
-		}
-	}
-} // namespace Scrobbling::ListenBrainz
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/FeedbacksSynchronizer.hpp b/src/libs/services/scrobbling/impl/listenbrainz/FeedbacksSynchronizer.hpp
deleted file mode 100644
index b0115d7d..00000000
--- a/src/libs/services/scrobbling/impl/listenbrainz/FeedbacksSynchronizer.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (C) 2021 Emeric Poupon
- *
- * This file is part of LMS.
- *
- * LMS is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * LMS 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include <optional>
-#include <unordered_map>
-#include <boost/asio/io_context.hpp>
-#include <boost/asio/io_context_strand.hpp>
-#include <boost/asio/steady_timer.hpp>
-
-#include "services/database/Types.hpp"
-#include "services/database/UserId.hpp"
-
-#include "services/scrobbling/Listen.hpp"
-
-#include "FeedbackTypes.hpp"
-
-
-namespace Database
-{
-	class Db;
-}
-
-namespace Http
-{
-	class IClient;
-}
-
-namespace Scrobbling::ListenBrainz
-{
-	class FeedbacksSynchronizer
-	{
-		public:
-			FeedbacksSynchronizer(boost::asio::io_context& ioContext, Database::Db& db, Http::IClient& client);
-
-			void enqueFeedback(FeedbackType type, Database::StarredTrackId starredTrackId);
-
-		private:
-			void onFeedbackSent(FeedbackType type, Database::StarredTrackId starredTrackId);
-
-			void enquePendingFeedbacks();
-
-			struct UserContext
-			{
-				UserContext(Database::UserId id) : userId {id} {}
-
-				UserContext(const UserContext&) = delete;
-				UserContext(UserContext&&) = delete;
-				UserContext& operator=(const UserContext&) = delete;
-				UserContext& operator=(UserContext&&) = delete;
-
-				const Database::UserId		userId;
-				bool						syncing {};
-				std::optional<std::size_t>	feedbackCount {};
-
-				// resetted at each sync
-				std::string		listenBrainzUserName; // need to be resolved first
-
-				std::size_t		currentOffset{};
-				std::size_t		fetchedFeedbackCount{};
-				std::size_t		matchedFeedbackCount{};
-				std::size_t		importedFeedbackCount{};
-			};
-
-			UserContext& getUserContext(Database::UserId userId);
-			bool isSyncing() const;
-			void scheduleSync(std::chrono::seconds fromNow);
-			void startSync();
-			void startSync(UserContext& context);
-			void onSyncEnded(UserContext& context);
-			void enqueValidateToken(UserContext& context);
-			void enqueGetFeedbackCount(UserContext& context);
-			void enqueGetFeedbacks(UserContext& context);
-			std::size_t processGetFeedbacks(std::string_view body, UserContext& context);
-			void tryImportFeedback(const Feedback& feedback, UserContext& context);
-
-			boost::asio::io_context&		_ioContext;
-			boost::asio::io_context::strand	_strand {_ioContext};
-			Database::Db&					_db;
-			boost::asio::steady_timer		_syncTimer {_ioContext};
-			Http::IClient&					_client;
-
-			std::unordered_map<Database::UserId, UserContext> _userContexts;
-
-			const std::size_t			_maxSyncFeedbackCount;
-			const std::chrono::hours	_syncFeedbacksPeriod;
-	};
-} // Scrobbling::ListenBrainz
-
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzBackend.cpp b/src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzBackend.cpp
new file mode 100644
index 00000000..1b1a4350
--- /dev/null
+++ b/src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzBackend.cpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2021 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ListenBrainzBackend.hpp"
+
+#include "services/database/Db.hpp"
+#include "services/database/Session.hpp"
+#include "services/database/Track.hpp"
+#include "utils/IConfig.hpp"
+#include "utils/http/IClient.hpp"
+#include "utils/Logger.hpp"
+#include "utils/Service.hpp"
+#include "Utils.hpp"
+
+namespace Scrobbling::ListenBrainz
+{
+    using namespace Database;
+
+    namespace
+    {
+        bool canBeScrobbled(Session& session, TrackId trackId, std::chrono::seconds duration)
+        {
+            auto transaction{ session.createSharedTransaction() };
+
+            const Track::pointer track{ Track::find(session, trackId) };
+            if (!track)
+                return false;
+
+            const bool res{ duration >= std::chrono::minutes(4) || (duration >= track->getDuration() / 2) };
+            if (!res)
+                LOG(DEBUG) << "Track cannot be scrobbled since played duration is too short: " << duration.count() << "s, total duration = " << std::chrono::duration_cast<std::chrono::seconds>(track->getDuration()).count() << "s";
+
+            return res;
+        }
+    }
+
+    ListenBrainzBackend::ListenBrainzBackend(boost::asio::io_context& ioContext, Db& db)
+        : _ioContext{ ioContext }
+        , _db{ db }
+        , _baseAPIUrl{ Service<IConfig>::get()->getString("listenbrainz-api-base-url", "https://api.listenbrainz.org") }
+        , _client{ Http::createClient(_ioContext, _baseAPIUrl) }
+        , _listensSynchronizer{ _ioContext, db, *_client }
+    {
+        LOG(INFO) << "Starting ListenBrainz backend... API endpoint = '" << _baseAPIUrl << "'";
+    }
+
+    ListenBrainzBackend::~ListenBrainzBackend()
+    {
+        LOG(INFO) << "Stopped ListenBrainz backend!";
+    }
+
+    void ListenBrainzBackend::listenStarted(const Listen& listen)
+    {
+        _listensSynchronizer.enqueListenNow(listen);
+    }
+
+    void ListenBrainzBackend::listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration)
+    {
+        if (duration && !canBeScrobbled(_db.getTLSSession(), listen.trackId, *duration))
+            return;
+
+        const TimedListen timedListen{ listen, Wt::WDateTime::currentDateTime() };
+        _listensSynchronizer.enqueListen(timedListen);
+    }
+
+    void ListenBrainzBackend::addTimedListen(const TimedListen& timedListen)
+    {
+        _listensSynchronizer.enqueListen(timedListen);
+    }
+} // namespace Scrobbling::ListenBrainz
+
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzBackend.hpp b/src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzBackend.hpp
new file mode 100644
index 00000000..887dc84f
--- /dev/null
+++ b/src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzBackend.hpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2021 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <string>
+#include <optional>
+#include <boost/asio/io_context.hpp>
+
+#include "IScrobblingBackend.hpp"
+#include "ListensSynchronizer.hpp"
+
+namespace Database
+{
+    class Db;
+}
+
+namespace Scrobbling::ListenBrainz
+{
+    class ListenBrainzBackend final : public IScrobblingBackend
+    {
+    public:
+        ListenBrainzBackend(boost::asio::io_context& ioContext, Database::Db& db);
+        ~ListenBrainzBackend() override;
+
+    private:
+        ListenBrainzBackend(const ListenBrainzBackend&) = delete;
+        ListenBrainzBackend& operator=(const ListenBrainzBackend&) = delete;
+
+        void listenStarted(const Listen& listen) override;
+        void listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration) override;
+        void addTimedListen(const TimedListen& listen) override;
+
+        // Submit listens
+        void enqueListen(const Listen& listen, const Wt::WDateTime& timePoint);
+
+        boost::asio::io_context&        _ioContext;
+        Database::Db&                   _db;
+        std::string                     _baseAPIUrl;
+        std::unique_ptr<Http::IClient>  _client;
+        ListensSynchronizer             _listensSynchronizer;
+    };
+} // Scrobbling::ListenBrainz
+
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzScrobbler.cpp b/src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzScrobbler.cpp
deleted file mode 100644
index 063a9987..00000000
--- a/src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzScrobbler.cpp
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- * Copyright (C) 2021 Emeric Poupon
- *
- * This file is part of LMS.
- *
- * LMS is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * LMS 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "ListenBrainzScrobbler.hpp"
-
-#include "services/database/Db.hpp"
-#include "services/database/Session.hpp"
-#include "services/database/StarredArtist.hpp"
-#include "services/database/StarredRelease.hpp"
-#include "services/database/Track.hpp"
-#include "utils/IConfig.hpp"
-#include "utils/http/IClient.hpp"
-#include "utils/Logger.hpp"
-#include "utils/Service.hpp"
-#include "Utils.hpp"
-
-using namespace Database;
-
-namespace
-{
-	bool
-	canBeScrobbled(Session& session, TrackId trackId, std::chrono::seconds duration)
-	{
-		auto transaction {session.createSharedTransaction()};
-
-		const Track::pointer track {Track::find(session, trackId)};
-		if (!track)
-			return false;
-
-		const bool res {duration >= std::chrono::minutes(4) || (duration >= track->getDuration() / 2)};
-		if (!res)
-			LOG(DEBUG) << "Track cannot be scrobbled since played duration is too short: " << duration.count() << "s, total duration = " << std::chrono::duration_cast<std::chrono::seconds>(track->getDuration()).count() << "s";
-
-		return res;
-	}
-
-	template <typename StarredObjType>
-	void onStarred(Database::Session& session, typename StarredObjType::IdType id)
-	{
-		auto transaction {session.createUniqueTransaction()};
-
-		if (auto starredObj {StarredObjType::find(session, id)})
-		{
-			// maybe in the future this will be supported by ListenBrainz so set it to PendingAdd
-			starredObj.modify()->setScrobblingState(Database::ScrobblingState::PendingAdd);
-		}
-	}
-
-	template <typename StarredObjType>
-	void onUnstarred(Database::Session& session, typename StarredObjType::IdType id)
-	{
-		auto transaction {session.createUniqueTransaction()};
-
-		if (auto starredObj {StarredObjType::find(session, id)})
-			starredObj.remove();
-	}
-}
-
-namespace Scrobbling::ListenBrainz
-{
-	Scrobbler::Scrobbler(boost::asio::io_context& ioContext, Db& db)
-		: _ioContext {ioContext}
-		, _db {db}
-		, _baseAPIUrl {Service<IConfig>::get()->getString("listenbrainz-api-base-url", "https://api.listenbrainz.org")}
-		, _client {Http::createClient(_ioContext, _baseAPIUrl)}
-		, _listensSynchronizer {_ioContext, db, *_client}
-		, _feedbacksSynchronizer {_ioContext, db, *_client}
-	{
-		LOG(INFO) << "Starting ListenBrainz scrobbler... API endpoint = '" << _baseAPIUrl << "'";
-	}
-
-	Scrobbler::~Scrobbler()
-	{
-		LOG(INFO) << "Stopped ListenBrainz scrobbler!";
-	}
-
-	void
-	Scrobbler::listenStarted(const Listen& listen)
-	{
-		_listensSynchronizer.enqueListenNow(listen);
-	}
-
-	void
-	Scrobbler::listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration)
-	{
-		if (duration && !canBeScrobbled(_db.getTLSSession(), listen.trackId, *duration))
-			return;
-
-		const TimedListen timedListen {listen, Wt::WDateTime::currentDateTime()};
-		_listensSynchronizer.enqueListen(timedListen);
-	}
-
-	void
-	Scrobbler::addTimedListen(const TimedListen& timedListen)
-	{
-		_listensSynchronizer.enqueListen(timedListen);
-	}
-
-	void
-	Scrobbler::onStarred(StarredArtistId starredArtistId)
-	{
-		::onStarred<StarredArtist>(_db.getTLSSession(), starredArtistId);
-	}
-
-	void
-	Scrobbler::onUnstarred(StarredArtistId starredArtistId)
-	{
-		::onUnstarred<StarredArtist>(_db.getTLSSession(), starredArtistId);
-	}
-
-	void
-	Scrobbler::onStarred(StarredReleaseId starredReleaseId)
-	{
-		::onStarred<StarredRelease>(_db.getTLSSession(), starredReleaseId);
-	}
-
-	void
-	Scrobbler::onUnstarred(StarredReleaseId starredReleaseId)
-	{
-		::onUnstarred<StarredRelease>(_db.getTLSSession(), starredReleaseId);
-	}
-
-	void
-	Scrobbler::onStarred(StarredTrackId starredTrackId)
-	{
-		_feedbacksSynchronizer.enqueFeedback(FeedbackType::Love, starredTrackId);
-	}
-
-	void
-	Scrobbler::onUnstarred(StarredTrackId starredtrackId)
-	{
-		_feedbacksSynchronizer.enqueFeedback(FeedbackType::Erase, starredtrackId);
-	}
-} // namespace Scrobbling::ListenBrainz
-
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzScrobbler.hpp b/src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzScrobbler.hpp
deleted file mode 100644
index e91159f6..00000000
--- a/src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzScrobbler.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (C) 2021 Emeric Poupon
- *
- * This file is part of LMS.
- *
- * LMS is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * LMS 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include <string>
-#include <optional>
-#include <boost/asio/io_context.hpp>
-
-#include "IScrobbler.hpp"
-#include "FeedbacksSynchronizer.hpp"
-#include "ListensSynchronizer.hpp"
-
-namespace Database
-{
-	class Db;
-}
-
-namespace Scrobbling::ListenBrainz
-{
-	class Scrobbler final : public IScrobbler
-	{
-		public:
-			Scrobbler(boost::asio::io_context& ioContext, Database::Db& db);
-			~Scrobbler();
-
-			Scrobbler(const Scrobbler&) = delete;
-			Scrobbler(const Scrobbler&&) = delete;
-			Scrobbler& operator=(const Scrobbler&) = delete;
-			Scrobbler& operator=(const Scrobbler&&) = delete;
-
-		private:
-			void listenStarted(const Listen& listen) override;
-			void listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration) override;
-			void addTimedListen(const TimedListen& listen) override;
-
-			// Submit listens
-			void enqueListen(const Listen& listen, const Wt::WDateTime& timePoint);
-
-			// Star
-			void onStarred(Database::StarredArtistId starredArtistId) override;
-			void onUnstarred(Database::StarredArtistId starredArtistId) override;
-			void onStarred(Database::StarredReleaseId starredReleaseId) override;
-			void onUnstarred(Database::StarredReleaseId starredReleaseId) override;
-			void onStarred(Database::StarredTrackId starredTrackId) override;
-			void onUnstarred(Database::StarredTrackId starredTrackId) override;
-
-			boost::asio::io_context&		_ioContext;
-			Database::Db&					_db;
-			std::string						_baseAPIUrl;
-			std::unique_ptr<Http::IClient>	_client;
-			ListensSynchronizer				_listensSynchronizer;
-			FeedbacksSynchronizer			_feedbacksSynchronizer;
-	};
-} // Scrobbling::ListenBrainz
-
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/ListensSynchronizer.cpp b/src/libs/services/scrobbling/impl/listenbrainz/ListensSynchronizer.cpp
index caf42117..b72a5238 100644
--- a/src/libs/services/scrobbling/impl/listenbrainz/ListensSynchronizer.cpp
+++ b/src/libs/services/scrobbling/impl/listenbrainz/ListensSynchronizer.cpp
@@ -17,9 +17,8 @@
  * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "ListenBrainzScrobbler.hpp"
+#include "ListensSynchronizer.hpp"
 
-#include <tuple>
 #include <boost/asio/bind_executor.hpp>
 #include <Wt/Json/Array.h>
 #include <Wt/Json/Object.h>
@@ -43,549 +42,530 @@
 
 namespace
 {
-	using namespace Scrobbling::ListenBrainz;
+    using namespace Scrobbling::ListenBrainz;
 
-	std::optional<Wt::Json::Object>
-	listenToJsonPayload(Database::Session& session, const Scrobbling::Listen& listen, const Wt::WDateTime& timePoint)
-	{
-		auto transaction {session.createSharedTransaction()};
+    std::optional<Wt::Json::Object> listenToJsonPayload(Database::Session& session, const Scrobbling::Listen& listen, const Wt::WDateTime& timePoint)
+    {
+        auto transaction{ session.createSharedTransaction() };
 
-		const Database::Track::pointer track {Database::Track::find(session, listen.trackId)};
-		if (!track)
-			return std::nullopt;
+        const Database::Track::pointer track{ Database::Track::find(session, listen.trackId) };
+        if (!track)
+            return std::nullopt;
 
-		auto artists {track->getArtists({Database::TrackArtistLinkType::Artist})};
-		if (artists.empty())
-			artists = track->getArtists({Database::TrackArtistLinkType::ReleaseArtist});
+        auto artists{ track->getArtists({Database::TrackArtistLinkType::Artist}) };
+        if (artists.empty())
+            artists = track->getArtists({ Database::TrackArtistLinkType::ReleaseArtist });
 
-		if (artists.empty())
-		{
-			LOG(DEBUG) << "Track cannot be scrobbled since it does not have any artist";
-			return std::nullopt;
-		}
+        if (artists.empty())
+        {
+            LOG(DEBUG) << "Track cannot be scrobbled since it does not have any artist";
+            return std::nullopt;
+        }
 
-		Wt::Json::Object additionalInfo;
-		additionalInfo["listening_from"] = "LMS";
-		if (track->getRelease())
-		{
-			if (auto MBID {track->getRelease()->getMBID()})
-				additionalInfo["release_mbid"] = Wt::Json::Value {std::string {MBID->getAsString()}};
-		}
+        Wt::Json::Object additionalInfo;
+        additionalInfo["listening_from"] = "LMS";
+        if (track->getRelease())
+        {
+            if (auto MBID{ track->getRelease()->getMBID() })
+                additionalInfo["release_mbid"] = Wt::Json::Value{ std::string {MBID->getAsString()} };
+        }
 
-		{
-			Wt::Json::Array artistMBIDs;
-			for (const Database::Artist::pointer& artist : artists)
-			{
-				if (auto MBID {artist->getMBID()})
-					artistMBIDs.push_back(Wt::Json::Value {std::string {MBID->getAsString()}});
-			}
+        {
+            Wt::Json::Array artistMBIDs;
+            for (const Database::Artist::pointer& artist : artists)
+            {
+                if (auto MBID{ artist->getMBID() })
+                    artistMBIDs.push_back(Wt::Json::Value{ std::string {MBID->getAsString()} });
+            }
 
-			if (!artistMBIDs.empty())
-				additionalInfo["artist_mbids"] = std::move(artistMBIDs);
-		}
+            if (!artistMBIDs.empty())
+                additionalInfo["artist_mbids"] = std::move(artistMBIDs);
+        }
 
-		if (auto MBID {track->getTrackMBID()})
-			additionalInfo["track_mbid"] = Wt::Json::Value {std::string {MBID->getAsString()}};
+        if (auto MBID{ track->getTrackMBID() })
+            additionalInfo["track_mbid"] = Wt::Json::Value{ std::string {MBID->getAsString()} };
 
-		if (auto MBID {track->getRecordingMBID()})
-			additionalInfo["recording_mbid"] = Wt::Json::Value {std::string {MBID->getAsString()}};
+        if (auto MBID{ track->getRecordingMBID() })
+            additionalInfo["recording_mbid"] = Wt::Json::Value{ std::string {MBID->getAsString()} };
 
-		if (const std::optional<std::size_t> trackNumber {track->getTrackNumber()})
-			additionalInfo["tracknumber"] = Wt::Json::Value {static_cast<long long int>(*trackNumber)};
+        if (const std::optional<std::size_t> trackNumber{ track->getTrackNumber() })
+            additionalInfo["tracknumber"] = Wt::Json::Value{ static_cast<long long int>(*trackNumber) };
 
-		Wt::Json::Object trackMetadata;
-		trackMetadata["additional_info"] = std::move(additionalInfo);
-		trackMetadata["artist_name"] = Wt::Json::Value {artists.front()->getName()};
-		trackMetadata["track_name"] = Wt::Json::Value {track->getName()};
-		if (track->getRelease())
-			trackMetadata["release_name"] = Wt::Json::Value {track->getRelease()->getName()};
+        Wt::Json::Object trackMetadata;
+        trackMetadata["additional_info"] = std::move(additionalInfo);
+        trackMetadata["artist_name"] = Wt::Json::Value{ artists.front()->getName() };
+        trackMetadata["track_name"] = Wt::Json::Value{ track->getName() };
+        if (track->getRelease())
+            trackMetadata["release_name"] = Wt::Json::Value{ track->getRelease()->getName() };
 
-		Wt::Json::Object payload;
-		payload["track_metadata"] = std::move(trackMetadata);
-		if (timePoint.isValid())
-			payload["listened_at"] = Wt::Json::Value {static_cast<long long int>(timePoint.toTime_t())};
+        Wt::Json::Object payload;
+        payload["track_metadata"] = std::move(trackMetadata);
+        if (timePoint.isValid())
+            payload["listened_at"] = Wt::Json::Value{ static_cast<long long int>(timePoint.toTime_t()) };
 
-		return payload;
-	}
+        return payload;
+    }
 
-	std::string
-	listenToJsonString(Database::Session& session, const Scrobbling::Listen& listen, const Wt::WDateTime& timePoint, std::string_view listenType)
-	{
-		std::string res;
+    std::string listenToJsonString(Database::Session& session, const Scrobbling::Listen& listen, const Wt::WDateTime& timePoint, std::string_view listenType)
+    {
+        std::string res;
 
-		std::optional<Wt::Json::Object> payload {listenToJsonPayload(session, listen, timePoint)};
-		if (!payload)
-			return res;
+        std::optional<Wt::Json::Object> payload{ listenToJsonPayload(session, listen, timePoint) };
+        if (!payload)
+            return res;
 
-		Wt::Json::Object root;
-		root["listen_type"] = Wt::Json::Value {std::string {listenType}};
-		root["payload"] = Wt::Json::Array {std::move(*payload)};
+        Wt::Json::Object root;
+        root["listen_type"] = Wt::Json::Value{ std::string {listenType} };
+        root["payload"] = Wt::Json::Array{ std::move(*payload) };
 
-		res = Wt::Json::serialize(root);
-		return res;
-	}
+        res = Wt::Json::serialize(root);
+        return res;
+    }
 
-	std::optional<std::size_t>
-	parseListenCount(std::string_view msgBody)
-	{
-		try
-		{
-			Wt::Json::Object root;
-			Wt::Json::parse(std::string {msgBody}, root);
+    std::optional<std::size_t> parseListenCount(std::string_view msgBody)
+    {
+        try
+        {
+            Wt::Json::Object root;
+            Wt::Json::parse(std::string{ msgBody }, root);
 
-			const Wt::Json::Object& payload {static_cast<const Wt::Json::Object&>(root.get("payload"))};
-			return static_cast<int>(payload.get("count"));
-		}
-		catch (const Wt::WException& e)
-		{
-			LOG(ERROR) << "Cannot parse listen count response: " << e.what();
-			return std::nullopt;
-		}
-	}
+            const Wt::Json::Object& payload{ static_cast<const Wt::Json::Object&>(root.get("payload")) };
+            return static_cast<int>(payload.get("count"));
+        }
+        catch (const Wt::WException& e)
+        {
+            LOG(ERROR) << "Cannot parse listen count response: " << e.what();
+            return std::nullopt;
+        }
+    }
 
-	Database::TrackId
-	tryGetMatchingTrack(Database::Session& session, const Listen& listen)
-	{
-		using namespace Database;
+    Database::TrackId tryGetMatchingTrack(Database::Session& session, const Listen& listen)
+    {
+        using namespace Database;
 
-		auto transaction {session.createSharedTransaction()};
+        auto transaction{ session.createSharedTransaction() };
 
-		// first try to match using track MBID, and then fallback on possibly ambiguous info
-		if (listen.trackMBID)
-		{
-			const auto tracks {Track::findByMBID(session, *listen.trackMBID)};
-			// if duplicated files, do not record it (let the user correct its database)
-			if (tracks.size() == 1)
-			{
-				LOG(DEBUG) << "Matched listen '" << listen << "' using track MBID";
-				return tracks.front()->getId();
-			}
-			else if (tracks.size() > 1)
-			{
-				LOG(DEBUG) << "Too many matches for listen '" << listen << "' using track MBID!";
-				return {};
-			}
-		}
+        // first try to match using track MBID, and then fallback on possibly ambiguous info
+        if (listen.trackMBID)
+        {
+            const auto tracks{ Track::findByMBID(session, *listen.trackMBID) };
+            // if duplicated files, do not record it (let the user correct its database)
+            if (tracks.size() == 1)
+            {
+                LOG(DEBUG) << "Matched listen '" << listen << "' using track MBID";
+                return tracks.front()->getId();
+            }
+            else if (tracks.size() > 1)
+            {
+                LOG(DEBUG) << "Too many matches for listen '" << listen << "' using track MBID!";
+                return {};
+            }
+        }
 
-		if (listen.recordingMBID)
-		{
-			const auto tracks {Track::findByRecordingMBID(session, *listen.recordingMBID)};
-			// if duplicated files, do not record it (let the user correct its database)
-			if (tracks.size() == 1)
-			{
-				LOG(DEBUG) << "Matched listen '" << listen << "' using recording MBID";
-				return tracks.front()->getId();
-			}
-			else if (tracks.size() > 1)
-			{
-				LOG(DEBUG) << "Too many matches for listen '" << listen << "' using recording MBID!";
-				return {};
-			}
-		}
+        if (listen.recordingMBID)
+        {
+            const auto tracks{ Track::findByRecordingMBID(session, *listen.recordingMBID) };
+            // if duplicated files, do not record it (let the user correct its database)
+            if (tracks.size() == 1)
+            {
+                LOG(DEBUG) << "Matched listen '" << listen << "' using recording MBID";
+                return tracks.front()->getId();
+            }
+            else if (tracks.size() > 1)
+            {
+                LOG(DEBUG) << "Too many matches for listen '" << listen << "' using recording MBID!";
+                return {};
+            }
+        }
 
-		assert(!listen.trackName.empty() && !listen.artistName.empty());
+        assert(!listen.trackName.empty() && !listen.artistName.empty());
 
-		// TODO check release MBID?
-		Track::FindParameters params;
-		params.setName(listen.trackName);
-		params.setReleaseName(listen.releaseName);
-		params.setArtistName(listen.artistName);
-		if (listen.trackNumber)
-			params.setTrackNumber(*listen.trackNumber);
+        // TODO check release MBID?
+        Track::FindParameters params;
+        params.setName(listen.trackName);
+        params.setReleaseName(listen.releaseName);
+        params.setArtistName(listen.artistName);
+        if (listen.trackNumber)
+            params.setTrackNumber(*listen.trackNumber);
 
-		const auto tracks {Track::find(session, params)};
-		// conservative behavior: in case of multiple matches: reject
-		if (tracks.results.size() == 1)
-		{
-			LOG(DEBUG) << "Matched listen '" << listen << "' using metadata";
-			return tracks.results.front();
-		}
-		else if (tracks.results.size() > 1)
-		{
-			LOG(DEBUG) << "Too many matches for listen '" << listen << "' using metadata";
-			return {};
-		}
+        const auto tracks{ Track::findIds(session, params) };
+        // conservative behavior: in case of multiple matches: reject
+        if (tracks.results.size() == 1)
+        {
+            LOG(DEBUG) << "Matched listen '" << listen << "' using metadata";
+            return tracks.results.front();
+        }
+        else if (tracks.results.size() > 1)
+        {
+            LOG(DEBUG) << "Too many matches for listen '" << listen << "' using metadata";
+            return {};
+        }
 
-		LOG(DEBUG) << "No match for listen '" << listen << "'";
-		return {};
-	}
+        LOG(DEBUG) << "No match for listen '" << listen << "'";
+        return {};
+    }
 }
 
 namespace Scrobbling::ListenBrainz
 {
-	ListensSynchronizer::ListensSynchronizer(boost::asio::io_context& ioContext, Database::Db& db, Http::IClient& client)
-		: _ioContext {ioContext}
-		, _db {db}
-		, _client {client}
-		, _maxSyncListenCount {Service<IConfig>::get()->getULong("listenbrainz-max-sync-listen-count", 1000)}
-		, _syncListensPeriod {Service<IConfig>::get()->getULong("listenbrainz-sync-listens-period-hours", 1)}
-	{
-		LOG(INFO) << "Starting Listens synchronizer, maxSyncListenCount = " << _maxSyncListenCount << ", _syncListensPeriod = " << _syncListensPeriod.count() << " hours";
-
-		scheduleSync(std::chrono::seconds {30});
-	}
-
-	void
-	ListensSynchronizer::enqueListen(const TimedListen& listen)
-	{
-		assert(listen.listenedAt.isValid());
-		enqueListen(listen, listen.listenedAt);
-	}
-
-	void
-	ListensSynchronizer::enqueListenNow(const Scrobbling::Listen& listen)
-	{
-		enqueListen(listen, {});
-	}
-
-	void
-	ListensSynchronizer::enqueListen(const Scrobbling::Listen& listen, const Wt::WDateTime& timePoint)
-	{
-		Http::ClientPOSTRequestParameters request;
-		request.relativeUrl = "/1/submit-listens";
-
-		if (timePoint.isValid())
-		{
-			const TimedListen timedListen {listen, timePoint};
-			// We want the listen to be sent again later in case of failure, so we just save it as pending send
-			saveListen(timedListen, Database::ScrobblingState::PendingAdd);
-
-			request.priority = Http::ClientRequestParameters::Priority::Normal;
-			request.onSuccessFunc = [=](std::string_view)
-			{
-				_strand.dispatch([=]
-				{
-					if (saveListen(timedListen, Database::ScrobblingState::Synchronized))
-					{
-						UserContext& context {getUserContext(listen.userId)};
-						if (context.listenCount)
-							(*context.listenCount)++;
-					}
-				});
-			};
-			// on failure, this listen will be sent during the next sync
-		}
-		else
-		{
-			// We want "listen now" to appear as soon as possible
-			request.priority = Http::ClientRequestParameters::Priority::High;
-			// don't retry on failure
-		}
-
-		std::string bodyText {listenToJsonString(_db.getTLSSession(), listen, timePoint, timePoint.isValid() ? "single" : "playing_now")};
-		if (bodyText.empty())
-		{
-			LOG(DEBUG) << "Cannot convert listen to json: skipping";
-			return;
-		}
-
-		const std::optional<UUID> listenBrainzToken {Utils::getListenBrainzToken(_db.getTLSSession(), listen.userId)};
-		if (!listenBrainzToken)
-		{
-			LOG(DEBUG) << "No listenbrainz token found: skipping";
-			return;
-		}
-
-		request.message.addBodyText(bodyText);
-		request.message.addHeader("Authorization", "Token " + std::string {listenBrainzToken->getAsString()});
-		request.message.addHeader("Content-Type", "application/json");
-		_client.sendPOSTRequest(std::move(request));
-	}
-
-	bool
-	ListensSynchronizer::saveListen(const TimedListen& listen, Database::ScrobblingState scrobblingState)
-	{
-		using namespace Database;
-
-		Session& session {_db.getTLSSession()};
-		auto transaction {session.createUniqueTransaction()}; // TODO: unique only if needed
-
-		Database::Listen::pointer dbListen {Database::Listen::find(session, listen.userId, listen.trackId, Database::Scrobbler::ListenBrainz, listen.listenedAt)};
-		if (!dbListen)
-		{
-			const User::pointer user {User::find(session, listen.userId)};
-			if (!user)
-				return false;
-
-			const Track::pointer track {Track::find(session, listen.trackId)};
-			if (!track)
-				return false;
-
-			dbListen = session.create<Database::Listen>(user, track, Database::Scrobbler::ListenBrainz, listen.listenedAt);
-			dbListen.modify()->setScrobblingState(scrobblingState);
-
-			LOG(DEBUG) << "LISTEN CREATED for user " << user->getLoginName() << ", track '" << track->getName() << "' AT " << listen.listenedAt.toString();
-
-			return true;
-		}
-
-		if (dbListen->getScrobblingState() == scrobblingState)
-			return false;
-
-		dbListen.modify()->setScrobblingState(scrobblingState);
-		return true;
-	}
-
-	void
-	ListensSynchronizer::enquePendingListens()
-	{
-		std::vector<TimedListen> pendingListens;
-
-		{
-			Database::Session& session {_db.getTLSSession()};
-
-			auto transaction {session.createUniqueTransaction()};
-
-			Database::Listen::FindParameters params;
-			params.setScrobbler(Database::Scrobbler::ListenBrainz)
-					.setScrobblingState(Database::ScrobblingState::PendingAdd)
-					.setRange(Database::Range {0, 100}); // don't flood too much?
-
-			const Database::RangeResults results {Database::Listen::find(session, params)};
-			pendingListens.reserve(results.results.size());
-
-			for (Database::ListenId listenId : results.results)
-			{
-				const Database::Listen::pointer listen {Database::Listen::find(session, listenId)};
-
-				TimedListen timedListen;
-				timedListen.listenedAt = listen->getDateTime();
-				timedListen.userId = listen->getUser()->getId();
-				timedListen.trackId = listen->getTrack()->getId();
-
-				pendingListens.push_back(std::move(timedListen));
-			}
-		}
-
-		LOG(DEBUG) << "Queing " << pendingListens.size() << " pending listen";
-
-		for (const TimedListen& pendingListen : pendingListens)
-			enqueListen(pendingListen);
-	}
-
-	ListensSynchronizer::UserContext&
-	ListensSynchronizer::getUserContext(Database::UserId userId)
-	{
-		assert(_strand.running_in_this_thread());
-
-		auto itContext {_userContexts.find(userId)};
-		if (itContext == std::cend(_userContexts))
-		{
-			std::tie(itContext, std::ignore) = _userContexts.emplace(userId, userId);
-		}
-
-		return itContext->second;
-	}
-
-	bool
-	ListensSynchronizer::isSyncing() const
-	{
-		return std::any_of(std::cbegin(_userContexts), std::cend(_userContexts), [](const auto& contextEntry)
-				{
-					return contextEntry.second.syncing;
-				});
-	}
-
-	void
-	ListensSynchronizer::scheduleSync(std::chrono::seconds fromNow)
-	{
-		if (_syncListensPeriod.count() == 0 || _maxSyncListenCount == 0)
-			return;
-
-		LOG(DEBUG) << "Scheduled sync in " << fromNow.count() << " seconds...";
-		_syncTimer.expires_after(fromNow);
-		_syncTimer.async_wait(boost::asio::bind_executor(_strand, [this] (const boost::system::error_code& ec)
-		{
-			if (ec == boost::asio::error::operation_aborted)
-			{
-				LOG(DEBUG) << "getListens aborted";
-				return;
-			}
-			else if (ec)
-			{
-				throw Exception {"GetListens timer failure: " + std::string {ec.message()} };
-			}
-
-			startSync();
-		}));
-	}
-
-	void
-	ListensSynchronizer::startSync()
-	{
-		LOG(DEBUG) << "Starting sync!";
-
-		assert(!isSyncing());
-
-		enquePendingListens();
-
-		Database::RangeResults<Database::UserId> userIds;
-		{
-			Database::Session& session {_db.getTLSSession()};
-			auto transaction {session.createSharedTransaction()};
-			userIds = Database::User::find(_db.getTLSSession(), Database::User::FindParameters{}.setScrobbler(Database::Scrobbler::ListenBrainz));
-		}
-
-		for (const Database::UserId userId : userIds.results)
-			startSync(getUserContext(userId));
-
-		if (!isSyncing())
-			scheduleSync(_syncListensPeriod);
-	}
-
-	void
-	ListensSynchronizer::startSync(UserContext& context)
-	{
-		context.syncing = true;
-		context.listenBrainzUserName = "";
-		context.maxDateTime = {};
-		context.fetchedListenCount = 0;
-		context.matchedListenCount = 0;
-		context.importedListenCount = 0;
-
-		enqueValidateToken(context);
-	}
-
-	void
-	ListensSynchronizer::onSyncEnded(UserContext& context)
-	{
-		_strand.dispatch([this, &context]
-		{
-			LOG(INFO) << "Sync done for user '" << context.listenBrainzUserName << "', fetched: " << context.fetchedListenCount << ", matched: " << context.matchedListenCount << ", imported: " << context.importedListenCount;
-			context.syncing = false;
-
-			if (!isSyncing())
-				scheduleSync(_syncListensPeriod);
-		});
-	}
-
-	void
-	ListensSynchronizer::enqueValidateToken(UserContext& context)
-	{
-		assert(context.listenBrainzUserName.empty());
-
-		const std::optional<UUID> listenBrainzToken {Utils::getListenBrainzToken(_db.getTLSSession(), context.userId)};
-		if (!listenBrainzToken)
-		{
-			onSyncEnded(context);
-			return;
-		}
-
-		Http::ClientGETRequestParameters request;
-		request.priority = Http::ClientRequestParameters::Priority::Low;
-		request.relativeUrl = "/1/validate-token";
-		request.headers = { {"Authorization",  "Token " + std::string {listenBrainzToken->getAsString()}} };
-		request.onSuccessFunc = [this, &context] (std::string_view msgBody)
-			{
-				context.listenBrainzUserName = Utils::parseValidateToken(msgBody);
-				if (context.listenBrainzUserName.empty())
-				{
-					onSyncEnded(context);
-					return;
-				}
-				enqueGetListenCount(context);
-			};
-		request.onFailureFunc = [this, &context]
-			{
-				onSyncEnded(context);
-			};
-
-		_client.sendGETRequest(std::move(request));
-	}
-
-	void
-	ListensSynchronizer::enqueGetListenCount(UserContext& context)
-	{
-		assert(!context.listenBrainzUserName.empty());
-
-		Http::ClientGETRequestParameters request;
-		request.relativeUrl = "/1/user/" + std::string {context.listenBrainzUserName} + "/listen-count";
-		request.priority = Http::ClientRequestParameters::Priority::Low;
-		request.onSuccessFunc = [=, &context] (std::string_view msgBody)
-			{
-				_strand.dispatch([=, &context]
-				{
-					const auto listenCount = parseListenCount(msgBody);
-					if (listenCount)
-						LOG(DEBUG) << "Listen count for listenbrainz user '" << context.listenBrainzUserName << "' = " << *listenCount;
-
-					bool needSync {listenCount && (!context.listenCount || *context.listenCount != *listenCount)};
-					context.listenCount = listenCount;
-
-					if (!needSync)
-					{
-						onSyncEnded(context);
-						return;
-					}
-
-					context.maxDateTime = Wt::WDateTime::currentDateTime();
-					enqueGetListens(context);
-				});
-			};
-		request.onFailureFunc = [this, &context]
-			{
-				onSyncEnded(context);
-			};
-
-		_client.sendGETRequest(std::move(request));
-	}
-
-	void
-	ListensSynchronizer::enqueGetListens(UserContext& context)
-	{
-		assert(!context.listenBrainzUserName.empty());
-
-		Http::ClientGETRequestParameters request;
-		request.relativeUrl = "/1/user/" + context.listenBrainzUserName + "/listens?max_ts=" + std::to_string(context.maxDateTime.toTime_t());
-		request.priority = Http::ClientRequestParameters::Priority::Low;
-		request.onSuccessFunc = [=, &context] (std::string_view msgBody)
-			{
-				processGetListensResponse(msgBody, context);
-				if (context.fetchedListenCount >= _maxSyncListenCount || !context.maxDateTime.isValid())
-				{
-					onSyncEnded(context);
-					return;
-				}
-
-				enqueGetListens(context);
-			};
-		request.onFailureFunc = [=, &context]
-			{
-				onSyncEnded(context);
-			};
-
-		_client.sendGETRequest(std::move(request));
-	}
-
-	void
-	ListensSynchronizer::processGetListensResponse(std::string_view msgBody, UserContext& context)
-	{
-		Database::Session& session {_db.getTLSSession()};
-
-		context.maxDateTime = {}; // invalidate to break in case no more listens are fetched
-		ListensParser::Result result {ListensParser::parse(msgBody)};
-		context.fetchedListenCount += result.listenCount;
-
-		for (const Listen& parsedListen : result.listens)
-		{
-			// update oldest listen for the next query
-			if (!parsedListen.listenedAt.isValid())
-			{
-				LOG(DEBUG) << "Skipping entry due to invalid listenedAt";
-				continue;
-			}
-
-			if (!context.maxDateTime.isValid() || context.maxDateTime > parsedListen.listenedAt)
-				context.maxDateTime = parsedListen.listenedAt;
-
-			if (const Database::TrackId trackId {tryGetMatchingTrack(session, parsedListen)}; trackId.isValid())
-			{
-				context.matchedListenCount++;
-
-				const Scrobbling::TimedListen listen {{context.userId, trackId}, parsedListen.listenedAt};
-				if (saveListen(listen, Database::ScrobblingState::Synchronized))
-					context.importedListenCount++;
-			}
-		}
-	}
+    ListensSynchronizer::ListensSynchronizer(boost::asio::io_context& ioContext, Database::Db& db, Http::IClient& client)
+        : _ioContext{ ioContext }
+        , _db{ db }
+        , _client{ client }
+        , _maxSyncListenCount{ Service<IConfig>::get()->getULong("listenbrainz-max-sync-listen-count", 1000) }
+        , _syncListensPeriod{ Service<IConfig>::get()->getULong("listenbrainz-sync-listens-period-hours", 1) }
+    {
+        LOG(INFO) << "Starting Listens synchronizer, maxSyncListenCount = " << _maxSyncListenCount << ", _syncListensPeriod = " << _syncListensPeriod.count() << " hours";
+
+        scheduleSync(std::chrono::seconds{ 30 });
+    }
+
+    void ListensSynchronizer::enqueListen(const TimedListen& listen)
+    {
+        assert(listen.listenedAt.isValid());
+        enqueListen(listen, listen.listenedAt);
+    }
+
+    void ListensSynchronizer::enqueListenNow(const Scrobbling::Listen& listen)
+    {
+        enqueListen(listen, {});
+    }
+
+    void ListensSynchronizer::enqueListen(const Scrobbling::Listen& listen, const Wt::WDateTime& timePoint)
+    {
+        Http::ClientPOSTRequestParameters request;
+        request.relativeUrl = "/1/submit-listens";
+
+        if (timePoint.isValid())
+        {
+            const TimedListen timedListen{ listen, timePoint };
+            // We want the listen to be sent again later in case of failure, so we just save it as pending send
+            saveListen(timedListen, Database::SyncState::PendingAdd);
+
+            request.priority = Http::ClientRequestParameters::Priority::Normal;
+            request.onSuccessFunc = [=](std::string_view)
+                {
+                    _strand.dispatch([=]
+                        {
+                            if (saveListen(timedListen, Database::SyncState::Synchronized))
+                            {
+                                UserContext& context{ getUserContext(listen.userId) };
+                                if (context.listenCount)
+                                    (*context.listenCount)++;
+                            }
+                        });
+                };
+            // on failure, this listen will be sent during the next sync
+        }
+        else
+        {
+            // We want "listen now" to appear as soon as possible
+            request.priority = Http::ClientRequestParameters::Priority::High;
+            // don't retry on failure
+        }
+
+        std::string bodyText{ listenToJsonString(_db.getTLSSession(), listen, timePoint, timePoint.isValid() ? "single" : "playing_now") };
+        if (bodyText.empty())
+        {
+            LOG(DEBUG) << "Cannot convert listen to json: skipping";
+            return;
+        }
+
+        const std::optional<UUID> listenBrainzToken{ Utils::getListenBrainzToken(_db.getTLSSession(), listen.userId) };
+        if (!listenBrainzToken)
+        {
+            LOG(DEBUG) << "No listenbrainz token found: skipping";
+            return;
+        }
+
+        request.message.addBodyText(bodyText);
+        request.message.addHeader("Authorization", "Token " + std::string{ listenBrainzToken->getAsString() });
+        request.message.addHeader("Content-Type", "application/json");
+        _client.sendPOSTRequest(std::move(request));
+    }
+
+    bool ListensSynchronizer::saveListen(const TimedListen& listen, Database::SyncState scrobblingState)
+    {
+        using namespace Database;
+
+        Session& session{ _db.getTLSSession() };
+        auto transaction{ session.createUniqueTransaction() }; // TODO: unique only if needed
+
+        Database::Listen::pointer dbListen{ Database::Listen::find(session, listen.userId, listen.trackId, Database::ScrobblingBackend::ListenBrainz, listen.listenedAt) };
+        if (!dbListen)
+        {
+            const User::pointer user{ User::find(session, listen.userId) };
+            if (!user)
+                return false;
+
+            const Track::pointer track{ Track::find(session, listen.trackId) };
+            if (!track)
+                return false;
+
+            dbListen = session.create<Database::Listen>(user, track, Database::ScrobblingBackend::ListenBrainz, listen.listenedAt);
+            dbListen.modify()->setSyncState(scrobblingState);
+
+            LOG(DEBUG) << "LISTEN CREATED for user " << user->getLoginName() << ", track '" << track->getName() << "' AT " << listen.listenedAt.toString();
+
+            return true;
+        }
+
+        if (dbListen->getSyncState() == scrobblingState)
+            return false;
+
+        dbListen.modify()->setSyncState(scrobblingState);
+        return true;
+    }
+
+    void ListensSynchronizer::enquePendingListens()
+    {
+        std::vector<TimedListen> pendingListens;
+
+        {
+            Database::Session& session{ _db.getTLSSession() };
+
+            auto transaction{ session.createUniqueTransaction() };
+
+            Database::Listen::FindParameters params;
+            params.setScrobblingBackend(Database::ScrobblingBackend::ListenBrainz)
+                .setSyncState(Database::SyncState::PendingAdd)
+                .setRange(Database::Range{ 0, 100 }); // don't flood too much?
+
+            const Database::RangeResults results{ Database::Listen::find(session, params) };
+            pendingListens.reserve(results.results.size());
+
+            for (Database::ListenId listenId : results.results)
+            {
+                const Database::Listen::pointer listen{ Database::Listen::find(session, listenId) };
+
+                TimedListen timedListen;
+                timedListen.listenedAt = listen->getDateTime();
+                timedListen.userId = listen->getUser()->getId();
+                timedListen.trackId = listen->getTrack()->getId();
+
+                pendingListens.push_back(std::move(timedListen));
+            }
+        }
+
+        LOG(DEBUG) << "Queing " << pendingListens.size() << " pending listen";
+
+        for (const TimedListen& pendingListen : pendingListens)
+            enqueListen(pendingListen);
+    }
+
+    ListensSynchronizer::UserContext& ListensSynchronizer::getUserContext(Database::UserId userId)
+    {
+        assert(_strand.running_in_this_thread());
+
+        auto itContext{ _userContexts.find(userId) };
+        if (itContext == std::cend(_userContexts))
+        {
+            std::tie(itContext, std::ignore) = _userContexts.emplace(userId, userId);
+        }
+
+        return itContext->second;
+    }
+
+    bool ListensSynchronizer::isSyncing() const
+    {
+        return std::any_of(std::cbegin(_userContexts), std::cend(_userContexts), [](const auto& contextEntry)
+            {
+                return contextEntry.second.syncing;
+            });
+    }
+
+    void ListensSynchronizer::scheduleSync(std::chrono::seconds fromNow)
+    {
+        if (_syncListensPeriod.count() == 0 || _maxSyncListenCount == 0)
+            return;
+
+        LOG(DEBUG) << "Scheduled sync in " << fromNow.count() << " seconds...";
+        _syncTimer.expires_after(fromNow);
+        _syncTimer.async_wait(boost::asio::bind_executor(_strand, [this](const boost::system::error_code& ec)
+            {
+                if (ec == boost::asio::error::operation_aborted)
+                {
+                    LOG(DEBUG) << "getListens aborted";
+                    return;
+                }
+                else if (ec)
+                {
+                    throw Exception{ "GetListens timer failure: " + std::string {ec.message()} };
+                }
+
+                startSync();
+            }));
+    }
+
+    void ListensSynchronizer::startSync()
+    {
+        LOG(DEBUG) << "Starting sync!";
+
+        assert(!isSyncing());
+
+        enquePendingListens();
+
+        Database::RangeResults<Database::UserId> userIds;
+        {
+            Database::Session& session{ _db.getTLSSession() };
+            auto transaction{ session.createSharedTransaction() };
+            userIds = Database::User::find(_db.getTLSSession(), Database::User::FindParameters{}.setScrobblingBackend(Database::ScrobblingBackend::ListenBrainz));
+        }
+
+        for (const Database::UserId userId : userIds.results)
+            startSync(getUserContext(userId));
+
+        if (!isSyncing())
+            scheduleSync(_syncListensPeriod);
+    }
+
+    void ListensSynchronizer::startSync(UserContext& context)
+    {
+        context.syncing = true;
+        context.listenBrainzUserName = "";
+        context.maxDateTime = {};
+        context.fetchedListenCount = 0;
+        context.matchedListenCount = 0;
+        context.importedListenCount = 0;
+
+        enqueValidateToken(context);
+    }
+
+    void ListensSynchronizer::onSyncEnded(UserContext& context)
+    {
+        _strand.dispatch([this, &context]
+            {
+                LOG(INFO) << "Sync done for user '" << context.listenBrainzUserName << "', fetched: " << context.fetchedListenCount << ", matched: " << context.matchedListenCount << ", imported: " << context.importedListenCount;
+                context.syncing = false;
+
+                if (!isSyncing())
+                    scheduleSync(_syncListensPeriod);
+            });
+    }
+
+    void ListensSynchronizer::enqueValidateToken(UserContext& context)
+    {
+        assert(context.listenBrainzUserName.empty());
+
+        const std::optional<UUID> listenBrainzToken{ Utils::getListenBrainzToken(_db.getTLSSession(), context.userId) };
+        if (!listenBrainzToken)
+        {
+            onSyncEnded(context);
+            return;
+        }
+
+        Http::ClientGETRequestParameters request;
+        request.priority = Http::ClientRequestParameters::Priority::Low;
+        request.relativeUrl = "/1/validate-token";
+        request.headers = { {"Authorization",  "Token " + std::string {listenBrainzToken->getAsString()}} };
+        request.onSuccessFunc = [this, &context](std::string_view msgBody)
+            {
+                context.listenBrainzUserName = Utils::parseValidateToken(msgBody);
+                if (context.listenBrainzUserName.empty())
+                {
+                    onSyncEnded(context);
+                    return;
+                }
+                enqueGetListenCount(context);
+            };
+        request.onFailureFunc = [this, &context]
+            {
+                onSyncEnded(context);
+            };
+
+        _client.sendGETRequest(std::move(request));
+    }
+
+    void ListensSynchronizer::enqueGetListenCount(UserContext& context)
+    {
+        assert(!context.listenBrainzUserName.empty());
+
+        Http::ClientGETRequestParameters request;
+        request.relativeUrl = "/1/user/" + std::string{ context.listenBrainzUserName } + "/listen-count";
+        request.priority = Http::ClientRequestParameters::Priority::Low;
+        request.onSuccessFunc = [=, &context](std::string_view msgBody)
+            {
+                _strand.dispatch([=, &context]
+                    {
+                        const auto listenCount = parseListenCount(msgBody);
+                        if (listenCount)
+                            LOG(DEBUG) << "Listen count for listenbrainz user '" << context.listenBrainzUserName << "' = " << *listenCount;
+
+                        bool needSync{ listenCount && (!context.listenCount || *context.listenCount != *listenCount) };
+                        context.listenCount = listenCount;
+
+                        if (!needSync)
+                        {
+                            onSyncEnded(context);
+                            return;
+                        }
+
+                        context.maxDateTime = Wt::WDateTime::currentDateTime();
+                        enqueGetListens(context);
+                    });
+            };
+        request.onFailureFunc = [this, &context]
+            {
+                onSyncEnded(context);
+            };
+
+        _client.sendGETRequest(std::move(request));
+    }
+
+    void ListensSynchronizer::enqueGetListens(UserContext& context)
+    {
+        assert(!context.listenBrainzUserName.empty());
+
+        Http::ClientGETRequestParameters request;
+        request.relativeUrl = "/1/user/" + context.listenBrainzUserName + "/listens?max_ts=" + std::to_string(context.maxDateTime.toTime_t());
+        request.priority = Http::ClientRequestParameters::Priority::Low;
+        request.onSuccessFunc = [=, &context](std::string_view msgBody)
+            {
+                processGetListensResponse(msgBody, context);
+                if (context.fetchedListenCount >= _maxSyncListenCount || !context.maxDateTime.isValid())
+                {
+                    onSyncEnded(context);
+                    return;
+                }
+
+                enqueGetListens(context);
+            };
+        request.onFailureFunc = [=, &context]
+            {
+                onSyncEnded(context);
+            };
+
+        _client.sendGETRequest(std::move(request));
+    }
+
+    void ListensSynchronizer::processGetListensResponse(std::string_view msgBody, UserContext& context)
+    {
+        Database::Session& session{ _db.getTLSSession() };
+
+        context.maxDateTime = {}; // invalidate to break in case no more listens are fetched
+        ListensParser::Result result{ ListensParser::parse(msgBody) };
+        context.fetchedListenCount += result.listenCount;
+
+        for (const Listen& parsedListen : result.listens)
+        {
+            // update oldest listen for the next query
+            if (!parsedListen.listenedAt.isValid())
+            {
+                LOG(DEBUG) << "Skipping entry due to invalid listenedAt";
+                continue;
+            }
+
+            if (!context.maxDateTime.isValid() || context.maxDateTime > parsedListen.listenedAt)
+                context.maxDateTime = parsedListen.listenedAt;
+
+            if (const Database::TrackId trackId{ tryGetMatchingTrack(session, parsedListen) }; trackId.isValid())
+            {
+                context.matchedListenCount++;
+
+                const Scrobbling::TimedListen listen{ {context.userId, trackId}, parsedListen.listenedAt };
+                if (saveListen(listen, Database::SyncState::Synchronized))
+                    context.importedListenCount++;
+            }
+        }
+    }
 } // namespace Scrobbling::ListenBrainz
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/ListensSynchronizer.hpp b/src/libs/services/scrobbling/impl/listenbrainz/ListensSynchronizer.hpp
index 0102409e..24686076 100644
--- a/src/libs/services/scrobbling/impl/listenbrainz/ListensSynchronizer.hpp
+++ b/src/libs/services/scrobbling/impl/listenbrainz/ListensSynchronizer.hpp
@@ -52,7 +52,7 @@ namespace Scrobbling::ListenBrainz
 
 		private:
 			void enqueListen(const Listen& listen, const Wt::WDateTime& timePoint);
-			bool saveListen(const TimedListen& listen, Database::ScrobblingState scrobblinState);
+			bool saveListen(const TimedListen& listen, Database::SyncState scrobblinState);
 
 			void enquePendingListens();
 
diff --git a/src/libs/services/scrobbling/impl/listenbrainz/Utils.hpp b/src/libs/services/scrobbling/impl/listenbrainz/Utils.hpp
index f3454f40..a02eaca7 100644
--- a/src/libs/services/scrobbling/impl/listenbrainz/Utils.hpp
+++ b/src/libs/services/scrobbling/impl/listenbrainz/Utils.hpp
@@ -19,12 +19,11 @@
 
 #pragma once
 
-#include "utils/UUID.hpp"
-
 #include "services/database/UserId.hpp"
 #include "utils/Logger.hpp"
+#include "utils/UUID.hpp"
 
-#define LOG(sev)	LMS_LOG(SCROBBLING, sev) << "[listenbrainz] - "
+#define LOG(sev)	LMS_LOG(SCROBBLING, sev) << "[listenbrainz] "
 
 namespace Database
 {
@@ -34,6 +33,5 @@ namespace Database
 namespace Scrobbling::ListenBrainz::Utils
 {
 	std::optional<UUID>	getListenBrainzToken(Database::Session& session, Database::UserId userId);
-
 	std::string parseValidateToken(std::string_view msgBody);
 }
diff --git a/src/libs/services/scrobbling/include/services/scrobbling/IScrobblingService.hpp b/src/libs/services/scrobbling/include/services/scrobbling/IScrobblingService.hpp
index 507f5ad4..fcabbdb6 100644
--- a/src/libs/services/scrobbling/include/services/scrobbling/IScrobblingService.hpp
+++ b/src/libs/services/scrobbling/include/services/scrobbling/IScrobblingService.hpp
@@ -55,59 +55,19 @@ namespace Scrobbling
         using ArtistContainer = Database::RangeResults<Database::ArtistId>;
         using ReleaseContainer = Database::RangeResults<Database::ReleaseId>;
         using TrackContainer = Database::RangeResults<Database::TrackId>;
+        
         // From most recent to oldest
-        virtual ArtistContainer getRecentArtists(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            std::optional<Database::TrackArtistLinkType> linkType,
-            Database::Range range) = 0;
-
-        virtual ReleaseContainer getRecentReleases(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            Database::Range range) = 0;
-
-        virtual TrackContainer getRecentTracks(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            Database::Range range) = 0;
+        virtual ArtistContainer getRecentArtists(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, std::optional<Database::TrackArtistLinkType> linkType, Database::Range range) = 0;
+        virtual ReleaseContainer getRecentReleases(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) = 0;
+        virtual TrackContainer getRecentTracks(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) = 0;
 
         virtual Wt::WDateTime getLastListenDateTime(Database::UserId userId, Database::ReleaseId releaseId) = 0;
         virtual Wt::WDateTime getLastListenDateTime(Database::UserId userId, Database::TrackId trackId) = 0;
 
         // Top
-        virtual ArtistContainer getTopArtists(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            std::optional<Database::TrackArtistLinkType> linkType,
-            Database::Range) = 0;
-
-        virtual ReleaseContainer getTopReleases(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            Database::Range range) = 0;
-
-        virtual TrackContainer getTopTracks(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            Database::Range range) = 0;
-
-        // Star
-        virtual void            star(Database::UserId userId, Database::ArtistId artistId) = 0;
-        virtual void            unstar(Database::UserId userId, Database::ArtistId artistId) = 0;
-        virtual bool            isStarred(Database::UserId userId, Database::ArtistId artistId) = 0;
-        virtual Wt::WDateTime   getStarredDateTime(Database::UserId userId, Database::ArtistId artistId) = 0;
-        virtual ArtistContainer	getStarredArtists(Database::UserId userId,
-            const std::vector<Database::ClusterId>& clusterIds,
-            std::optional<Database::TrackArtistLinkType> linkType,
-            Database::ArtistSortMethod sortMethod,
-            Database::Range range) = 0;
-
-        virtual void                star(Database::UserId userId, Database::ReleaseId releaseId) = 0;
-        virtual void                unstar(Database::UserId userId, Database::ReleaseId releaseId) = 0;
-        virtual bool                isStarred(Database::UserId userId, Database::ReleaseId artistId) = 0;
-        virtual Wt::WDateTime       getStarredDateTime(Database::UserId userId, Database::ReleaseId artistId) = 0;
-        virtual ReleaseContainer    getStarredReleases(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) = 0;
-
-        virtual void                star(Database::UserId userId, Database::TrackId trackId) = 0;
-        virtual void                unstar(Database::UserId userId, Database::TrackId trackId) = 0;
-        virtual bool                isStarred(Database::UserId userId, Database::TrackId artistId) = 0;
-        virtual Wt::WDateTime       getStarredDateTime(Database::UserId userId, Database::TrackId artistId) = 0;
-        virtual TrackContainer      getStarredTracks(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) = 0;
+        virtual ArtistContainer getTopArtists(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, std::optional<Database::TrackArtistLinkType> linkType, Database::Range) = 0;
+        virtual ReleaseContainer getTopReleases(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) = 0;
+        virtual TrackContainer getTopTracks(Database::UserId userId, const std::vector<Database::ClusterId>& clusterIds, Database::Range range) = 0;
     };
 
     std::unique_ptr<IScrobblingService> createScrobblingService(boost::asio::io_service& ioService, Database::Db& db);
diff --git a/src/libs/subsonic/CMakeLists.txt b/src/libs/subsonic/CMakeLists.txt
index 8964a561..2ba6eda8 100644
--- a/src/libs/subsonic/CMakeLists.txt
+++ b/src/libs/subsonic/CMakeLists.txt
@@ -42,6 +42,7 @@ target_link_libraries(lmssubsonic PRIVATE
 	lmsauth
 	lmsav
 	lmsdatabase
+	lmsfeedback
 	lmsrecommendation
 	lmsscanner
 	lmsscrobbling
diff --git a/src/libs/subsonic/impl/RequestContext.hpp b/src/libs/subsonic/impl/RequestContext.hpp
index 4f2801bc..05de5b5a 100644
--- a/src/libs/subsonic/impl/RequestContext.hpp
+++ b/src/libs/subsonic/impl/RequestContext.hpp
@@ -41,6 +41,7 @@ namespace API::Subsonic
         Database::UserId userId;
         ClientInfo clientInfo;
         ProtocolVersion serverProtocolVersion;
+        bool enableOpenSubsonic{ true };
     };
 }
 
diff --git a/src/libs/subsonic/impl/SubsonicResource.cpp b/src/libs/subsonic/impl/SubsonicResource.cpp
index 4b62014c..e5b0bb0d 100644
--- a/src/libs/subsonic/impl/SubsonicResource.cpp
+++ b/src/libs/subsonic/impl/SubsonicResource.cpp
@@ -75,6 +75,18 @@ namespace API::Subsonic
             return res;
         }
 
+        std::unordered_set<std::string> readOpenSubsonicDisabledClients()
+        {
+            std::unordered_set<std::string> res;
+
+            Service<IConfig>::get()->visitStrings("api-open-subsonic-disabled-clients",
+                [&](std::string_view client)
+                {
+                    res.emplace(std::string{ client });
+                }, { "DSub" });
+
+            return res;
+        }
 
         std::string parameterMapToDebugString(const Wt::Http::ParameterMap& parameterMap)
         {
@@ -253,6 +265,7 @@ namespace API::Subsonic
 
     SubsonicResource::SubsonicResource(Db& db)
         : _serverProtocolVersionsByClient{ readConfigProtocolVersions() }
+        , _openSubsonicDisabledClients{ readOpenSubsonicDisabledClients() }
         , _db{ db }
     {
     }
@@ -273,13 +286,13 @@ namespace API::Subsonic
         const ResponseFormat format{ getParameterAs<std::string>(request.getParameterMap(), "f").value_or("xml") == "json" ? ResponseFormat::json : ResponseFormat::xml };
 
         ProtocolVersion protocolVersion{ defaultServerProtocolVersion };
-
+        
         try
         {
             // We need to parse client a soon as possible to make sure to answer with the right protocol version
             protocolVersion = getServerProtocolVersion(getMandatoryParameterAs<std::string>(request.getParameterMap(), "c"));
             RequestContext requestContext{ buildRequestContext(request) };
-
+            
             auto itEntryPoint{ requestEntryPoints.find(requestPath) };
             if (itEntryPoint != requestEntryPoints.end())
             {
@@ -364,8 +377,9 @@ namespace API::Subsonic
         const Wt::Http::ParameterMap& parameters{ request.getParameterMap() };
         const ClientInfo clientInfo{ getClientInfo(parameters) };
         const Database::UserId userId{ authenticateUser(request, clientInfo) };
+        bool enableOpenSubsonic{ _openSubsonicDisabledClients.find(clientInfo.name) == std::cend(_openSubsonicDisabledClients) };
 
-        return { parameters, _db.getTLSSession(), userId, clientInfo, getServerProtocolVersion(clientInfo.name) };
+        return { parameters, _db.getTLSSession(), userId, clientInfo, getServerProtocolVersion(clientInfo.name), enableOpenSubsonic };
     }
 
     Database::UserId SubsonicResource::authenticateUser(const Wt::Http::Request& request, const ClientInfo& clientInfo)
diff --git a/src/libs/subsonic/impl/SubsonicResource.hpp b/src/libs/subsonic/impl/SubsonicResource.hpp
index 643ca504..63a04a5c 100644
--- a/src/libs/subsonic/impl/SubsonicResource.hpp
+++ b/src/libs/subsonic/impl/SubsonicResource.hpp
@@ -19,6 +19,7 @@
 #pragma once
 
 #include <string>
+#include <unordered_set>
 #include <unordered_map>
 
 #include <Wt/WResource.h>
@@ -51,6 +52,7 @@ namespace API::Subsonic
             Database::UserId authenticateUser(const Wt::Http::Request& request, const ClientInfo& clientInfo);
 
             const std::unordered_map<std::string, ProtocolVersion> _serverProtocolVersionsByClient;
+            const std::unordered_set<std::string> _openSubsonicDisabledClients;
             Database::Db& _db;
     };
 
diff --git a/src/libs/subsonic/impl/SubsonicResponse.cpp b/src/libs/subsonic/impl/SubsonicResponse.cpp
index 01762ecc..c5d971e3 100644
--- a/src/libs/subsonic/impl/SubsonicResponse.cpp
+++ b/src/libs/subsonic/impl/SubsonicResponse.cpp
@@ -148,6 +148,7 @@ namespace API::Subsonic
         }
 
         // OpenSubsonic mandatory fields
+        // No big deal to send them even for legacy clients
         responseNode.setAttribute("type", "lms");
         responseNode.setAttribute("serverVersion", serverVersion);
         responseNode.setAttribute("openSubsonic", true);
diff --git a/src/libs/subsonic/impl/entrypoints/AlbumSongLists.cpp b/src/libs/subsonic/impl/entrypoints/AlbumSongLists.cpp
index 2cb08ca0..721577d0 100644
--- a/src/libs/subsonic/impl/entrypoints/AlbumSongLists.cpp
+++ b/src/libs/subsonic/impl/entrypoints/AlbumSongLists.cpp
@@ -25,6 +25,7 @@
 #include "services/database/Session.hpp"
 #include "services/database/Track.hpp"
 #include "services/database/User.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "services/scrobbling/IScrobblingService.hpp"
 #include "responses/Album.hpp"
 #include "responses/Artist.hpp"
@@ -36,8 +37,9 @@ namespace API::Subsonic
 {
     using namespace Database;
 
-    namespace {
-        Response handleGetAlbumListRequestCommon(const RequestContext& context, bool id3)
+    namespace
+    {
+        Response handleGetAlbumListRequestCommon(RequestContext& context, bool id3)
         {
             // Mandatory params
             const std::string type{ getMandatoryParameterAs<std::string>(context.parameters, "type") };
@@ -49,7 +51,8 @@ namespace API::Subsonic
             const Range range{ offset, size };
 
             RangeResults<ReleaseId> releases;
-            Scrobbling::IScrobblingService& scrobbling{ *Service<Scrobbling::IScrobblingService>::get() };
+            Scrobbling::IScrobblingService& scrobblingService{ *Service<Scrobbling::IScrobblingService>::get() };
+            Feedback::IFeedbackService& feedbackService{ *Service<Feedback::IFeedbackService>::get() };
 
             auto transaction{ context.dbSession.createSharedTransaction() };
 
@@ -63,11 +66,11 @@ namespace API::Subsonic
                 params.setSortMethod(ReleaseSortMethod::Name);
                 params.setRange(range);
 
-                releases = Release::find(context.dbSession, params);
+                releases = Release::findIds(context.dbSession, params);
             }
             else if (type == "alphabeticalByArtist")
             {
-                releases = Release::findOrderedByArtist(context.dbSession, range);
+                releases = Release::findIdsOrderedByArtist(context.dbSession, range);
             }
             else if (type == "byGenre")
             {
@@ -83,7 +86,7 @@ namespace API::Subsonic
                         params.setSortMethod(ReleaseSortMethod::Name);
                         params.setRange(range);
 
-                        releases = Release::find(context.dbSession, params);
+                        releases = Release::findIds(context.dbSession, params);
                     }
                 }
             }
@@ -97,11 +100,11 @@ namespace API::Subsonic
                 params.setRange(range);
                 params.setDateRange(DateRange::fromYearRange(fromYear, toYear));
 
-                releases = Release::find(context.dbSession, params);
+                releases = Release::findIds(context.dbSession, params);
             }
             else if (type == "frequent")
             {
-                releases = scrobbling.getTopReleases(context.userId, {}, range);
+                releases = scrobblingService.getTopReleases(context.userId, {}, range);
             }
             else if (type == "newest")
             {
@@ -109,7 +112,7 @@ namespace API::Subsonic
                 params.setSortMethod(ReleaseSortMethod::LastWritten);
                 params.setRange(range);
 
-                releases = Release::find(context.dbSession, params);
+                releases = Release::findIds(context.dbSession, params);
             }
             else if (type == "random")
             {
@@ -119,15 +122,15 @@ namespace API::Subsonic
                 params.setSortMethod(ReleaseSortMethod::Random);
                 params.setRange({ 0, size });
 
-                releases = Release::find(context.dbSession, params);
+                releases = Release::findIds(context.dbSession, params);
             }
             else if (type == "recent")
             {
-                releases = scrobbling.getRecentReleases(context.userId, {}, range);
+                releases = scrobblingService.getRecentReleases(context.userId, {}, range);
             }
             else if (type == "starred")
             {
-                releases = scrobbling.getStarredReleases(context.userId, {}, range);
+                releases = feedbackService.getStarredReleases(context.userId, {}, range);
             }
             else
                 throw NotImplementedGenericError{};
@@ -138,7 +141,7 @@ namespace API::Subsonic
             for (const ReleaseId releaseId : releases.results)
             {
                 const Release::pointer release{ Release::find(context.dbSession, releaseId) };
-                albumListNode.addArrayChild("album", createAlbumNode(release, context.dbSession, user, id3));
+                albumListNode.addArrayChild("album", createAlbumNode(context, release, user, id3));
             }
 
             return response;
@@ -155,24 +158,24 @@ namespace API::Subsonic
             Response response{ Response::createOkResponse(context.serverProtocolVersion) };
             Response::Node& starredNode{ response.createNode(id3 ? Response::Node::Key{ "starred2" } : Response::Node::Key{ "starred" }) };
 
-            Scrobbling::IScrobblingService& scrobbling{ *Service<Scrobbling::IScrobblingService>::get() };
+            Feedback::IFeedbackService& feedbackService{ *Service<Feedback::IFeedbackService>::get() };
 
-            for (const ArtistId artistId : scrobbling.getStarredArtists(context.userId, {} /* clusters */, std::nullopt /* linkType */, ArtistSortMethod::BySortName, Range{}).results)
+            for (const ArtistId artistId : feedbackService.getStarredArtists(context.userId, {} /* clusters */, std::nullopt /* linkType */, ArtistSortMethod::BySortName, Range{}).results)
             {
                 if (auto artist{ Artist::find(context.dbSession, artistId) })
-                    starredNode.addArrayChild("artist", createArtistNode(artist, context.dbSession, user, id3));
+                    starredNode.addArrayChild("artist", createArtistNode(context, artist, user, id3));
             }
 
-            for (const ReleaseId releaseId : scrobbling.getStarredReleases(context.userId, {} /* clusters */, Range{}).results)
+            for (const ReleaseId releaseId : feedbackService.getStarredReleases(context.userId, {} /* clusters */, Range{}).results)
             {
                 if (auto release{ Release::find(context.dbSession, releaseId) })
-                    starredNode.addArrayChild("album", createAlbumNode(release, context.dbSession, user, id3));
+                    starredNode.addArrayChild("album", createAlbumNode(context, release, user, id3));
             }
 
-            for (const TrackId trackId : scrobbling.getStarredTracks(context.userId, {} /* clusters */, Range{}).results)
+            for (const TrackId trackId : feedbackService.getStarredTracks(context.userId, {} /* clusters */, Range{}).results)
             {
                 if (auto track{ Track::find(context.dbSession, trackId) })
-                    starredNode.addArrayChild("song", createSongNode(track, context.dbSession, user));
+                    starredNode.addArrayChild("song", createSongNode(context, track, user));
             }
 
             return response;
@@ -201,16 +204,13 @@ namespace API::Subsonic
         if (!user)
             throw UserNotAuthorizedError{};
 
-        const auto trackIds{ Track::find(context.dbSession, Track::FindParameters {}.setSortMethod(TrackSortMethod::Random).setRange({0, size})) };
+        const auto tracks{ Track::find(context.dbSession, Track::FindParameters {}.setSortMethod(TrackSortMethod::Random).setRange({0, size})) };
 
         Response response{ Response::createOkResponse(context.serverProtocolVersion) };
 
         Response::Node& randomSongsNode{ response.createNode("randomSongs") };
-        for (const TrackId trackId : trackIds.results)
-        {
-            const Track::pointer track{ Track::find(context.dbSession, trackId) };
-            randomSongsNode.addArrayChild("song", createSongNode(track, context.dbSession, user));
-        }
+        for (const Track::pointer& track : tracks.results)
+            randomSongsNode.addArrayChild("song", createSongNode(context, track, user));
 
         return response;
     }
@@ -247,12 +247,9 @@ namespace API::Subsonic
         params.setClusters({ cluster->getId() });
         params.setRange({ offset, size });
 
-        auto trackIds{ Track::find(context.dbSession, params) };
-        for (const TrackId trackId : trackIds.results)
-        {
-            const Track::pointer track{ Track::find(context.dbSession, trackId) };
-            songsByGenreNode.addArrayChild("song", createSongNode(track, context.dbSession, user));
-        }
+        const auto tracks{ Track::find(context.dbSession, params) };
+        for (const Track::pointer& track : tracks.results)
+            songsByGenreNode.addArrayChild("song", createSongNode(context, track, user));
 
         return response;
     }
diff --git a/src/libs/subsonic/impl/entrypoints/Bookmarks.cpp b/src/libs/subsonic/impl/entrypoints/Bookmarks.cpp
index 2e007cdf..a149555c 100644
--- a/src/libs/subsonic/impl/entrypoints/Bookmarks.cpp
+++ b/src/libs/subsonic/impl/entrypoints/Bookmarks.cpp
@@ -49,7 +49,7 @@ namespace API::Subsonic
         {
             const TrackBookmark::pointer bookmark{ TrackBookmark::find(context.dbSession, bookmarkId) };
             Response::Node bookmarkNode{ createBookmarkNode(bookmark) };
-            bookmarkNode.addArrayChild("entry", createSongNode(bookmark->getTrack(), context.dbSession, user));
+            bookmarkNode.addArrayChild("entry", createSongNode(context, bookmark->getTrack(), user));
 
             bookmarksNode.addArrayChild("bookmark", std::move(bookmarkNode));
         }
diff --git a/src/libs/subsonic/impl/entrypoints/Browsing.cpp b/src/libs/subsonic/impl/entrypoints/Browsing.cpp
index ad525f4e..16b8ed8d 100644
--- a/src/libs/subsonic/impl/entrypoints/Browsing.cpp
+++ b/src/libs/subsonic/impl/entrypoints/Browsing.cpp
@@ -26,6 +26,7 @@
 #include "services/database/Track.hpp"
 #include "services/database/User.hpp"
 #include "services/recommendation/IRecommendationService.hpp"
+#include "utils/Logger.hpp"
 #include "utils/Random.hpp"
 #include "utils/Service.hpp"
 #include "responses/Album.hpp"
@@ -81,7 +82,7 @@ namespace API::Subsonic
                 {
                     const Artist::pointer similarArtist{ Artist::find(context.dbSession, similarArtistId) };
                     if (similarArtist)
-                        artistInfoNode.addArrayChild("similarArtist", createArtistNode(similarArtist, context.dbSession, user, id3));
+                        artistInfoNode.addArrayChild("similarArtist", createArtistNode(context, similarArtist, user, id3));
                 }
             }
 
@@ -94,52 +95,78 @@ namespace API::Subsonic
 
             Response::Node& artistsNode{ response.createNode(id3 ? "artists" : "indexes") };
             artistsNode.setAttribute("ignoredArticles", "");
-            artistsNode.setAttribute("lastModified", reportedDummyDateULong);
-
-            auto transaction{ context.dbSession.createSharedTransaction() };
-
-            User::pointer user{ User::find(context.dbSession, context.userId) };
-            if (!user)
-                throw UserNotAuthorizedError{};
+            artistsNode.setAttribute("lastModified", reportedDummyDateULong); // TODO report last file write?
 
             Artist::FindParameters parameters;
-            parameters.setSortMethod(ArtistSortMethod::BySortName);
-            switch (user->getSubsonicArtistListMode())
             {
-            case SubsonicArtistListMode::AllArtists:
-                break;
-            case SubsonicArtistListMode::ReleaseArtists:
-                parameters.setLinkType(TrackArtistLinkType::ReleaseArtist);
-                break;
-            case SubsonicArtistListMode::TrackArtists:
-                parameters.setLinkType(TrackArtistLinkType::Artist);
-                break;
+                auto transaction{ context.dbSession.createSharedTransaction() };
+
+                User::pointer user{ User::find(context.dbSession, context.userId) };
+                if (!user)
+                    throw UserNotAuthorizedError{};
+
+                parameters.setSortMethod(ArtistSortMethod::BySortName);
+                switch (user->getSubsonicArtistListMode())
+                {
+                case SubsonicArtistListMode::AllArtists:
+                    break;
+                case SubsonicArtistListMode::ReleaseArtists:
+                    parameters.setLinkType(TrackArtistLinkType::ReleaseArtist);
+                    break;
+                case SubsonicArtistListMode::TrackArtists:
+                    parameters.setLinkType(TrackArtistLinkType::Artist);
+                    break;
+                }
             }
 
-            std::map<char, std::vector<Artist::pointer>> artistsSortedByFirstChar;
-            const RangeResults<ArtistId> artists{ Artist::find(context.dbSession, parameters) };
-            for (const ArtistId artistId : artists.results)
+            // This endpoint does not scale: make sort lived transactions in order not to block the whole application
+
+            // first pass: dispatch the artists by first letter
+            LMS_LOG(API_SUBSONIC, DEBUG) << "GetArtists: fetching all artists...";
+            std::map<char, std::vector<ArtistId>> artistsSortedByFirstChar;
+            std::size_t currentArtistOffset{0};
+            constexpr std::size_t batchSize{ 100 };
+            bool hasMoreArtists{ true };
+            while (hasMoreArtists)
             {
-                const Artist::pointer artist{ Artist::find(context.dbSession, artistId) };
-                const std::string& sortName{ artist->getSortName() };
+                auto transaction{ context.dbSession.createSharedTransaction() };
 
-                char sortChar;
-                if (sortName.empty() || !std::isalpha(sortName[0]))
-                    sortChar = '?';
-                else
-                    sortChar = std::toupper(sortName[0]);
+                parameters.setRange(Range{ currentArtistOffset, batchSize });
+                const auto artists{ Artist::find(context.dbSession, parameters) };
+                for (const Artist::pointer& artist : artists.results)
+                {
+                    std::string_view sortName{ artist->getSortName() };
 
-                artistsSortedByFirstChar[sortChar].push_back(artist);
+                    char sortChar;
+                    if (sortName.empty() || !std::isalpha(sortName[0]))
+                        sortChar = '?';
+                    else
+                        sortChar = std::toupper(sortName[0]);
+
+                    artistsSortedByFirstChar[sortChar].push_back(artist->getId());
+                }
+
+                hasMoreArtists = artists.moreResults;
+                currentArtistOffset += artists.results.size();
             }
 
-
-            for (const auto& [sortChar, artists] : artistsSortedByFirstChar)
+            // second pass: add each artist
+            LMS_LOG(API_SUBSONIC, DEBUG) << "GetArtists: constructing response...";
+            for (const auto& [sortChar, artistIds] : artistsSortedByFirstChar)
             {
                 Response::Node& indexNode{ artistsNode.createArrayChild("index") };
                 indexNode.setAttribute("name", std::string{ sortChar });
 
-                for (const Artist::pointer& artist : artists)
-                    indexNode.addArrayChild("artist", createArtistNode(artist, context.dbSession, user, id3));
+                for (const ArtistId artistId : artistIds)
+                {
+                    auto transaction{ context.dbSession.createSharedTransaction() };
+                    User::pointer user{ User::find(context.dbSession, context.userId) };
+                    if (!user)
+                        throw UserNotAuthorizedError{};
+
+                    if (const Artist::pointer artist{ Artist::find(context.dbSession, artistId) })
+                        indexNode.addArrayChild("artist", createArtistNode(context, artist, user, id3));
+                }
             }
 
             return response;
@@ -166,7 +193,7 @@ namespace API::Subsonic
                 params.setRange({ 0, meanTrackCountPerArtist });
                 params.setSortMethod(TrackSortMethod::Random);
 
-                const auto artistTracks{ Track::find(context.dbSession, params) };
+                const auto artistTracks{ Track::findIds(context.dbSession, params) };
                 tracks.insert(std::end(tracks),
                     std::begin(artistTracks.results),
                     std::end(artistTracks.results));
@@ -197,7 +224,7 @@ namespace API::Subsonic
                 params.setRange({ 0, meanTrackCountPerRelease });
                 params.setSortMethod(TrackSortMethod::Random);
 
-                const auto releaseTracks{ Track::find(context.dbSession, params) };
+                const auto releaseTracks{ Track::findIds(context.dbSession, params) };
                 tracks.insert(std::end(tracks),
                     std::begin(releaseTracks.results),
                     std::end(releaseTracks.results));
@@ -240,7 +267,7 @@ namespace API::Subsonic
             for (const TrackId trackId : tracks)
             {
                 const Track::pointer track{ Track::find(context.dbSession, trackId) };
-                similarSongsNode.addArrayChild("song", createSongNode(track, context.dbSession, user));
+                similarSongsNode.addArrayChild("song", createSongNode(context, track, user));
             }
 
             return response;
@@ -289,12 +316,9 @@ namespace API::Subsonic
             directoryNode.setAttribute("id", idToString(RootId{}));
             directoryNode.setAttribute("name", "Music");
 
-            auto rootArtistIds{ Artist::find(context.dbSession, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::BySortName)) };
-            for (const ArtistId rootArtistId : rootArtistIds.results)
-            {
-                const Artist::pointer artist{ Artist::find(context.dbSession, rootArtistId) };
-                directoryNode.addArrayChild("child", createArtistNode(artist, context.dbSession, user, false /* no id3 */));
-            }
+            const auto rootArtistIds{ Artist::find(context.dbSession, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::BySortName)) };
+            for (const Artist::pointer& artist : rootArtistIds.results)
+                directoryNode.addArrayChild("child", createArtistNode(context, artist, user, false /* no id3 */));
         }
         else if (artistId)
         {
@@ -307,11 +331,8 @@ namespace API::Subsonic
             directoryNode.setAttribute("name", Utils::makeNameFilesystemCompatible(artist->getName()));
 
             const auto artistReleases{ Release::find(context.dbSession, Release::FindParameters {}.setArtist(*artistId)) };
-            for (const ReleaseId artistReleaseId : artistReleases.results)
-            {
-                const Release::pointer release{ Release::find(context.dbSession, artistReleaseId) };
-                directoryNode.addArrayChild("child", createAlbumNode(release, context.dbSession, user, false /* no id3 */));
-            }
+            for (const Release::pointer& release : artistReleases.results)
+                directoryNode.addArrayChild("child", createAlbumNode(context, release, user, false /* no id3 */));
         }
         else if (releaseId)
         {
@@ -324,11 +345,8 @@ namespace API::Subsonic
             directoryNode.setAttribute("name", Utils::makeNameFilesystemCompatible(release->getName()));
 
             const auto tracks{ Track::find(context.dbSession, Track::FindParameters {}.setRelease(*releaseId).setSortMethod(TrackSortMethod::Release)) };
-            for (const TrackId trackId : tracks.results)
-            {
-                const Track::pointer track{ Track::find(context.dbSession, trackId) };
-                directoryNode.addArrayChild("child", createSongNode(track, context.dbSession, user));
-            }
+            for (const Track::pointer& track : tracks.results)
+                directoryNode.addArrayChild("child", createSongNode(context, track, user));
         }
         else
             throw BadParameterGenericError{ "id" };
@@ -377,14 +395,11 @@ namespace API::Subsonic
             throw UserNotAuthorizedError{};
 
         Response response{ Response::createOkResponse(context.serverProtocolVersion) };
-        Response::Node artistNode{ createArtistNode(artist, context.dbSession, user, true /* id3 */) };
+        Response::Node artistNode{ createArtistNode(context, artist, user, true /* id3 */) };
 
         const auto releases{ Release::find(context.dbSession, Release::FindParameters {}.setArtist(artist->getId())) };
-        for (const ReleaseId releaseId : releases.results)
-        {
-            const Release::pointer release{ Release::find(context.dbSession, releaseId) };
-            artistNode.addArrayChild("album", createAlbumNode(release, context.dbSession, user, true /* id3 */));
-        }
+        for (const Release::pointer& release : releases.results)
+            artistNode.addArrayChild("album", createAlbumNode(context, release, user, true /* id3 */));
 
         response.addNode("artist", std::move(artistNode));
 
@@ -407,14 +422,11 @@ namespace API::Subsonic
             throw UserNotAuthorizedError{};
 
         Response response{ Response::createOkResponse(context.serverProtocolVersion) };
-        Response::Node albumNode{ createAlbumNode(release, context.dbSession, user, true /* id3 */) };
+        Response::Node albumNode{ createAlbumNode(context, release, user, true /* id3 */) };
 
         const auto tracks{ Track::find(context.dbSession, Track::FindParameters {}.setRelease(id).setSortMethod(TrackSortMethod::Release)) };
-        for (const TrackId trackId : tracks.results)
-        {
-            const Track::pointer track{ Track::find(context.dbSession, trackId) };
-            albumNode.addArrayChild("song", createSongNode(track, context.dbSession, user));
-        }
+        for (const Track::pointer& track : tracks.results)
+            albumNode.addArrayChild("song", createSongNode(context, track, user));
 
         response.addNode("album", std::move(albumNode));
 
@@ -437,7 +449,7 @@ namespace API::Subsonic
             throw UserNotAuthorizedError{};
 
         Response response{ Response::createOkResponse(context.serverProtocolVersion) };
-        response.addNode("song", createSongNode(track, context.dbSession, user));
+        response.addNode("song", createSongNode(context, track, user));
 
         return response;
     }
diff --git a/src/libs/subsonic/impl/entrypoints/MediaAnnotation.cpp b/src/libs/subsonic/impl/entrypoints/MediaAnnotation.cpp
index 96aa7c2c..2f7d8d6a 100644
--- a/src/libs/subsonic/impl/entrypoints/MediaAnnotation.cpp
+++ b/src/libs/subsonic/impl/entrypoints/MediaAnnotation.cpp
@@ -24,6 +24,7 @@
 #include "services/database/ArtistId.hpp"
 #include "services/database/ReleaseId.hpp"
 #include "services/database/TrackId.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "services/scrobbling/IScrobblingService.hpp"
 #include "utils/Service.hpp"
 #include "ParameterParsing.hpp"
@@ -60,13 +61,13 @@ namespace API::Subsonic
         StarParameters params{ getStarParameters(context.parameters) };
 
         for (const ArtistId id : params.artistIds)
-            Service<Scrobbling::IScrobblingService>::get()->star(context.userId, id);
+            Service<Feedback::IFeedbackService>::get()->star(context.userId, id);
 
         for (const ReleaseId id : params.releaseIds)
-            Service<Scrobbling::IScrobblingService>::get()->star(context.userId, id);
+            Service<Feedback::IFeedbackService>::get()->star(context.userId, id);
 
         for (const TrackId id : params.trackIds)
-            Service<Scrobbling::IScrobblingService>::get()->star(context.userId, id);
+            Service<Feedback::IFeedbackService>::get()->star(context.userId, id);
 
         return Response::createOkResponse(context.serverProtocolVersion);
     }
@@ -76,13 +77,13 @@ namespace API::Subsonic
         StarParameters params{ getStarParameters(context.parameters) };
 
         for (const ArtistId id : params.artistIds)
-            Service<Scrobbling::IScrobblingService>::get()->unstar(context.userId, id);
+            Service<Feedback::IFeedbackService>::get()->unstar(context.userId, id);
 
         for (const ReleaseId id : params.releaseIds)
-            Service<Scrobbling::IScrobblingService>::get()->unstar(context.userId, id);
+            Service<Feedback::IFeedbackService>::get()->unstar(context.userId, id);
 
         for (const TrackId id : params.trackIds)
-            Service<Scrobbling::IScrobblingService>::get()->unstar(context.userId, id);
+            Service<Feedback::IFeedbackService>::get()->unstar(context.userId, id);
 
         return Response::createOkResponse(context.serverProtocolVersion);
     }
diff --git a/src/libs/subsonic/impl/entrypoints/Playlists.cpp b/src/libs/subsonic/impl/entrypoints/Playlists.cpp
index 63b896a3..8e52efbf 100644
--- a/src/libs/subsonic/impl/entrypoints/Playlists.cpp
+++ b/src/libs/subsonic/impl/entrypoints/Playlists.cpp
@@ -73,7 +73,7 @@ namespace API::Subsonic
 
         auto entries{ tracklist->getEntries() };
         for (const TrackListEntry::pointer& entry : entries)
-            playlistNode.addArrayChild("entry", createSongNode(entry->getTrack(), context.dbSession, user));
+            playlistNode.addArrayChild("entry", createSongNode(context, entry->getTrack(), user));
 
         response.addNode("playlist", std::move(playlistNode));
 
diff --git a/src/libs/subsonic/impl/entrypoints/Searching.cpp b/src/libs/subsonic/impl/entrypoints/Searching.cpp
index 59f3cfdd..a3ed2968 100644
--- a/src/libs/subsonic/impl/entrypoints/Searching.cpp
+++ b/src/libs/subsonic/impl/entrypoints/Searching.cpp
@@ -70,30 +70,20 @@ namespace API::Subsonic
             {
                 Artist::FindParameters params;
                 params.setKeywords(keywords);
-                params.setSortMethod(ArtistSortMethod::BySortName);
                 params.setRange({ artistOffset, artistCount });
 
-                RangeResults<ArtistId> artistIds{ Artist::find(context.dbSession, params) };
-                for (const ArtistId artistId : artistIds.results)
-                {
-                    const auto artist{ Artist::find(context.dbSession, artistId) };
-                    searchResult2Node.addArrayChild("artist", createArtistNode(artist, context.dbSession, user, id3));
-                }
+                for (const Artist::pointer& artist : Artist::find(context.dbSession, params).results)
+                    searchResult2Node.addArrayChild("artist", createArtistNode(context, artist, user, id3));
             }
 
             if (albumCount > 0)
             {
                 Release::FindParameters params;
                 params.setKeywords(keywords);
-                params.setSortMethod(ReleaseSortMethod::Name);
                 params.setRange({ albumOffset, albumCount });
 
-                RangeResults<ReleaseId> releaseIds{ Release::find(context.dbSession, params) };
-                for (const ReleaseId releaseId : releaseIds.results)
-                {
-                    const auto release{ Release::find(context.dbSession, releaseId) };
-                    searchResult2Node.addArrayChild("album", createAlbumNode(release, context.dbSession, user, id3));
-                }
+                for (const Release::pointer& release : Release::find(context.dbSession, params).results)
+                    searchResult2Node.addArrayChild("album", createAlbumNode(context, release, user, id3));
             }
 
             if (songCount > 0)
@@ -102,12 +92,8 @@ namespace API::Subsonic
                 params.setKeywords(keywords);
                 params.setRange({ songOffset, songCount });
 
-                RangeResults<TrackId> trackIds{ Track::find(context.dbSession, params) };
-                for (const TrackId trackId : trackIds.results)
-                {
-                    const auto track{ Track::find(context.dbSession, trackId) };
-                    searchResult2Node.addArrayChild("song", createSongNode(track, context.dbSession, user));
-                }
+                for (const Track::pointer& track : Track::find(context.dbSession, params).results)
+                    searchResult2Node.addArrayChild("song", createSongNode(context, track, user));
             }
 
             return response;
diff --git a/src/libs/subsonic/impl/entrypoints/System.cpp b/src/libs/subsonic/impl/entrypoints/System.cpp
index 11d7b350..e28ca592 100644
--- a/src/libs/subsonic/impl/entrypoints/System.cpp
+++ b/src/libs/subsonic/impl/entrypoints/System.cpp
@@ -12,7 +12,7 @@ namespace API::Subsonic
         Response response{ Response::createOkResponse(context.serverProtocolVersion) };
 
         Response::Node& licenseNode{ response.createNode("license") };
-        licenseNode.setAttribute("licenseExpires", "2025-09-03T14:46:43");
+        licenseNode.setAttribute("licenseExpires", "2035-09-03T14:46:43");
         licenseNode.setAttribute("email", "foo@bar.com");
         licenseNode.setAttribute("valid", true);
 
diff --git a/src/libs/subsonic/impl/responses/Album.cpp b/src/libs/subsonic/impl/responses/Album.cpp
index 0abb0b88..cbee51d6 100644
--- a/src/libs/subsonic/impl/responses/Album.cpp
+++ b/src/libs/subsonic/impl/responses/Album.cpp
@@ -19,10 +19,12 @@
 
 #include "responses/Album.hpp"
 
-#include "services/database/Cluster.hpp"
 #include "services/database/Artist.hpp"
+#include "services/database/Cluster.hpp"
+#include "services/database/Listen.hpp"
 #include "services/database/Release.hpp"
 #include "services/database/User.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "services/scrobbling/IScrobblingService.hpp"
 #include "utils/Service.hpp"
 #include "utils/String.hpp"
@@ -73,7 +75,7 @@ namespace API::Subsonic
         }
     }
 
-    Response::Node createAlbumNode(const Release::pointer& release, Session& dbSession, const User::pointer& user, bool id3)
+    Response::Node createAlbumNode(RequestContext& context, const Release::pointer& release, const User::pointer& user, bool id3)
     {
         Response::Node albumNode;
 
@@ -123,8 +125,10 @@ namespace API::Subsonic
             }
         }
 
+        albumNode.setAttribute("playCount", Listen::getCount(context.dbSession, user->getId(), user->getScrobblingBackend(), release->getId()));
+
         // Report the first GENRE for this track
-        const ClusterType::pointer genreClusterType{ ClusterType::find(dbSession, "GENRE") };
+        const ClusterType::pointer genreClusterType{ ClusterType::find(context.dbSession, "GENRE") };
         if (genreClusterType)
         {
             auto clusters{ release->getClusterGroups({genreClusterType}, 1) };
@@ -132,9 +136,12 @@ namespace API::Subsonic
                 albumNode.setAttribute("genre", clusters.front().front()->getName());
         }
 
-        if (const Wt::WDateTime dateTime{ Service<Scrobbling::IScrobblingService>::get()->getStarredDateTime(user->getId(), release->getId()) }; dateTime.isValid())
+        if (const Wt::WDateTime dateTime{ Service<Feedback::IFeedbackService>::get()->getStarredDateTime(user->getId(), release->getId()) }; dateTime.isValid())
             albumNode.setAttribute("starred", StringUtils::toISO8601String(dateTime));
 
+        if (!context.enableOpenSubsonic)
+            return albumNode;
+
         // OpenSubsonic specific fields (must always be set)
         if (!id3)
             albumNode.setAttribute("mediaType", "album");
@@ -153,14 +160,14 @@ namespace API::Subsonic
         {
             albumNode.createEmptyArrayValue(field);
 
-            ClusterType::pointer clusterType{ ClusterType::find(dbSession, clusterTypeName) };
+            ClusterType::pointer clusterType{ ClusterType::find(context.dbSession, clusterTypeName) };
             if (clusterType)
             {
                 Cluster::FindParameters params;
                 params.setRelease(release->getId());
                 params.setClusterType(clusterType->getId());
 
-                for (const auto& cluster : Cluster::find(dbSession, params).results)
+                for (const auto& cluster : Cluster::find(context.dbSession, params).results)
                     albumNode.addArrayValue(field, std::get<std::string>(cluster));
             }
         } };
@@ -175,7 +182,7 @@ namespace API::Subsonic
             params.setRelease(release->getId());
             params.setClusterType(genreClusterType->getId());
 
-            for (const auto& cluster : Cluster::find(dbSession, params).results)
+            for (const auto& cluster : Cluster::find(context.dbSession, params).results)
                 albumNode.addArrayChild("genres", createItemGenreNode(std::get<std::string>(cluster)));
         }
 
diff --git a/src/libs/subsonic/impl/responses/Album.hpp b/src/libs/subsonic/impl/responses/Album.hpp
index c05c1f35..ba57f39b 100644
--- a/src/libs/subsonic/impl/responses/Album.hpp
+++ b/src/libs/subsonic/impl/responses/Album.hpp
@@ -31,5 +31,5 @@ namespace Database
 
 namespace API::Subsonic
 {
-    Response::Node createAlbumNode(const Database::ObjectPtr<Database::Release>& release, Database::Session& dbSession, const Database::ObjectPtr<Database::User>& user, bool id3);
+    Response::Node createAlbumNode(RequestContext& context, const Database::ObjectPtr<Database::Release>& release, const Database::ObjectPtr<Database::User>& user, bool id3);
 }
\ No newline at end of file
diff --git a/src/libs/subsonic/impl/responses/Artist.cpp b/src/libs/subsonic/impl/responses/Artist.cpp
index 59505c18..bd7c6cf2 100644
--- a/src/libs/subsonic/impl/responses/Artist.cpp
+++ b/src/libs/subsonic/impl/responses/Artist.cpp
@@ -23,7 +23,7 @@
 #include "services/database/Release.hpp"
 #include "services/database/TrackArtistLink.hpp"
 #include "services/database/User.hpp"
-#include "services/scrobbling/IScrobblingService.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "utils/Service.hpp"
 #include "utils/String.hpp"
 
@@ -73,7 +73,7 @@ namespace API::Subsonic
         }
     }
 
-    Response::Node createArtistNode(const Artist::pointer& artist, Session& session, const User::pointer& user, bool id3)
+    Response::Node createArtistNode(RequestContext& context, const Artist::pointer& artist, const User::pointer& user, bool id3)
     {
         Response::Node artistNode{ createArtistNode(artist) };
 
@@ -82,30 +82,33 @@ namespace API::Subsonic
 
         if (id3)
         {
-            const auto releases{ Release::find(session, Release::FindParameters {}.setArtist(artist->getId())) };
+            const auto releases{ Release::find(context.dbSession, Release::FindParameters {}.setArtist(artist->getId())) };
             artistNode.setAttribute("albumCount", releases.results.size());
         }
 
-        if (const Wt::WDateTime dateTime{ Service<Scrobbling::IScrobblingService>::get()->getStarredDateTime(user->getId(), artist->getId()) }; dateTime.isValid())
+        if (const Wt::WDateTime dateTime{ Service<Feedback::IFeedbackService>::get()->getStarredDateTime(user->getId(), artist->getId()) }; dateTime.isValid())
             artistNode.setAttribute("starred", StringUtils::toISO8601String(dateTime));
 
         // OpenSubsonic specific fields (must always be set)
-        if (!id3)
-            artistNode.setAttribute("mediaType", "artist");
-
+        if (context.enableOpenSubsonic)
         {
-            std::optional<UUID> mbid{ artist->getMBID() };
-            artistNode.setAttribute("musicBrainzId", mbid ? mbid->getAsString() : "");
+            if (!id3)
+                artistNode.setAttribute("mediaType", "artist");
+
+            {
+                std::optional<UUID> mbid{ artist->getMBID() };
+                artistNode.setAttribute("musicBrainzId", mbid ? mbid->getAsString() : "");
+            }
+
+            artistNode.setAttribute("sortName", artist->getSortName());
+
+            // roles
+            Response::Node roles;
+            artistNode.createEmptyArrayValue("roles");
+            for (const TrackArtistLinkType linkType : TrackArtistLink::findUsedTypes(context.dbSession, artist->getId()))
+                artistNode.addArrayValue("roles", Utils::toString(linkType));
         }
 
-        artistNode.setAttribute("sortName", artist->getSortName());
-
-        // roles
-        Response::Node roles;
-        artistNode.createEmptyArrayValue("roles");
-        for (const TrackArtistLinkType linkType : TrackArtistLink::findUsedTypes(session, artist->getId()))
-            artistNode.addArrayValue("roles", Utils::toString(linkType));
-
         return artistNode;
     }
 
diff --git a/src/libs/subsonic/impl/responses/Artist.hpp b/src/libs/subsonic/impl/responses/Artist.hpp
index 4b293d5e..1e44eb10 100644
--- a/src/libs/subsonic/impl/responses/Artist.hpp
+++ b/src/libs/subsonic/impl/responses/Artist.hpp
@@ -39,6 +39,6 @@ namespace API::Subsonic
         std::string joinArtistNames(const std::vector<Database::ObjectPtr<Database::Artist>>& artists);
         std::string_view toString(Database::TrackArtistLinkType type);
     }
-    Response::Node createArtistNode(const Database::ObjectPtr<Database::Artist>& artist, Database::Session& session, const Database::ObjectPtr<Database::User>& user, bool id3);
+    Response::Node createArtistNode(RequestContext& context, const Database::ObjectPtr<Database::Artist>& artist, const Database::ObjectPtr<Database::User>& user, bool id3);
     Response::Node createArtistNode(const Database::ObjectPtr<Database::Artist>& artist); // only minimal info
 }
\ No newline at end of file
diff --git a/src/libs/subsonic/impl/responses/Song.cpp b/src/libs/subsonic/impl/responses/Song.cpp
index 543737f4..42150cfc 100644
--- a/src/libs/subsonic/impl/responses/Song.cpp
+++ b/src/libs/subsonic/impl/responses/Song.cpp
@@ -23,10 +23,12 @@
 
 #include "services/database/Artist.hpp"
 #include "services/database/Cluster.hpp"
+#include "services/database/Listen.hpp"
 #include "services/database/Release.hpp"
 #include "services/database/Track.hpp"
 #include "services/database/TrackArtistLink.hpp"
 #include "services/database/User.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "services/scrobbling/IScrobblingService.hpp"
 #include "utils/Service.hpp"
 #include "utils/String.hpp"
@@ -92,7 +94,7 @@ namespace API::Subsonic
         }
     }
 
-    Response::Node createSongNode(const Track::pointer& track, Session& dbSession, const User::pointer& user)
+    Response::Node createSongNode(RequestContext& context, const Track::pointer& track, const User::pointer& user)
     {
         Response::Node trackResponse;
 
@@ -105,9 +107,10 @@ namespace API::Subsonic
             trackResponse.setAttribute("discNumber", *track->getDiscNumber());
         if (track->getYear())
             trackResponse.setAttribute("year", *track->getYear());
-
+        trackResponse.setAttribute("playCount", Listen::getCount(context.dbSession, user->getId(), user->getScrobblingBackend(), track->getId()));
         trackResponse.setAttribute("path", getTrackPath(track));
         {
+            // TODO, store this in DB
             std::error_code ec;
             const auto fileSize{ std::filesystem::file_size(track->getPath(), ec) };
             if (!ec)
@@ -148,11 +151,11 @@ namespace API::Subsonic
         trackResponse.setAttribute("type", "music");
         trackResponse.setAttribute("created", StringUtils::toISO8601String(track->getLastWritten()));
 
-        if (const Wt::WDateTime dateTime{ Service<Scrobbling::IScrobblingService>::get()->getStarredDateTime(user->getId(), track->getId()) }; dateTime.isValid())
+        if (const Wt::WDateTime dateTime{ Service<Feedback::IFeedbackService>::get()->getStarredDateTime(user->getId(), track->getId()) }; dateTime.isValid())
             trackResponse.setAttribute("starred", StringUtils::toISO8601String(dateTime));
 
         // Report the first GENRE for this track
-        const ClusterType::pointer genreClusterType{ ClusterType::find(dbSession, "GENRE") };
+        const ClusterType::pointer genreClusterType{ ClusterType::find(context.dbSession, "GENRE") };
         if (genreClusterType)
         {
             auto clusters{ track->getClusterGroups({genreClusterType}, 1) };
@@ -161,6 +164,9 @@ namespace API::Subsonic
         }
 
         // OpenSubsonic specific fields (must always be set)
+        if (!context.enableOpenSubsonic)
+            return trackResponse;
+
         trackResponse.setAttribute("mediaType", "song");
 
         {
@@ -178,9 +184,9 @@ namespace API::Subsonic
             TrackArtistLink::FindParameters params;
             params.setTrack(track->getId());
 
-            for (const TrackArtistLinkId linkId : TrackArtistLink::find(dbSession, params).results)
+            for (const TrackArtistLinkId linkId : TrackArtistLink::find(context.dbSession, params).results)
             {
-                TrackArtistLink::pointer link{ TrackArtistLink::find(dbSession, linkId) };
+                TrackArtistLink::pointer link{ TrackArtistLink::find(context.dbSession, linkId) };
                 // Don't report artists nor release artists as they are set in dedicated fields
                 if (link && link->getType() != TrackArtistLinkType::Artist && link->getType() != TrackArtistLinkType::ReleaseArtist)
                     trackResponse.addArrayChild("contributors", createContributorNode(link));
@@ -195,9 +201,9 @@ namespace API::Subsonic
             params.setTrack(track->getId());
             params.setLinkType(type);
 
-            for (const TrackArtistLinkId linkId : TrackArtistLink::find(dbSession, params).results)
+            for (const TrackArtistLinkId linkId : TrackArtistLink::find(context.dbSession, params).results)
             {
-                TrackArtistLink::pointer link{ TrackArtistLink::find(dbSession, linkId) };
+                TrackArtistLink::pointer link{ TrackArtistLink::find(context.dbSession, linkId) };
                 if (link)
                     trackResponse.addArrayChild(nodeName, createArtistNode(link->getArtist()));
             }
@@ -214,14 +220,14 @@ namespace API::Subsonic
         {
             trackResponse.createEmptyArrayValue(field);
 
-            ClusterType::pointer clusterType{ ClusterType::find(dbSession, clusterTypeName) };
+            ClusterType::pointer clusterType{ ClusterType::find(context.dbSession, clusterTypeName) };
             if (clusterType)
             {
                 Cluster::FindParameters params;
                 params.setTrack(track->getId());
                 params.setClusterType(clusterType->getId());
 
-                for (const auto& cluster : Cluster::find(dbSession, params).results)
+                for (const auto& cluster : Cluster::find(context.dbSession, params).results)
                     trackResponse.addArrayValue(field, std::get<std::string>(cluster));
             }
         } };
@@ -236,7 +242,7 @@ namespace API::Subsonic
             params.setTrack(track->getId());
             params.setClusterType(genreClusterType->getId());
 
-            for (const auto& cluster : Cluster::find(dbSession, params).results)
+            for (const auto& cluster : Cluster::find(context.dbSession, params).results)
                 trackResponse.addArrayChild("genres", createItemGenreNode(std::get<std::string>(cluster)));
         }
 
diff --git a/src/libs/subsonic/impl/responses/Song.hpp b/src/libs/subsonic/impl/responses/Song.hpp
index 9fcba25e..acfefdac 100644
--- a/src/libs/subsonic/impl/responses/Song.hpp
+++ b/src/libs/subsonic/impl/responses/Song.hpp
@@ -31,5 +31,5 @@ namespace Database
 
 namespace API::Subsonic
 {
-    Response::Node createSongNode(const Database::ObjectPtr<Database::Track>& track, Database::Session& session, const Database::ObjectPtr<Database::User>& user);
+    Response::Node createSongNode(RequestContext& context, const Database::ObjectPtr<Database::Track>& track, const Database::ObjectPtr<Database::User>& user);
 }
\ No newline at end of file
diff --git a/src/libs/utils/impl/ChildProcess.cpp b/src/libs/utils/impl/ChildProcess.cpp
index 627bbcd9..b0c4aef2 100644
--- a/src/libs/utils/impl/ChildProcess.cpp
+++ b/src/libs/utils/impl/ChildProcess.cpp
@@ -173,7 +173,7 @@ ChildProcess::asyncRead(std::byte* data, std::size_t bufferSize, ReadCallback ca
 	boost::asio::async_read(_childStdout, boost::asio::buffer(data, bufferSize),
 		[this, callback {std::move(callback)}](const boost::system::error_code& error, std::size_t bytesTransferred)
 		{
-			LMS_LOG(CHILDPROCESS, DEBUG) << "Async read cb - ec = '" << error.message() << "', bytesTransferred = " << bytesTransferred;
+			LMS_LOG(CHILDPROCESS, DEBUG) << "Async read cb - ec = '" << error.message() << "' (" << error.value() << "), bytesTransferred = " << bytesTransferred;
 
 			ReadResult readResult {ReadResult::Success};
 			if (error)
diff --git a/src/libs/utils/impl/Logger.cpp b/src/libs/utils/impl/Logger.cpp
index 57d7a35d..604a2802 100644
--- a/src/libs/utils/impl/Logger.cpp
+++ b/src/libs/utils/impl/Logger.cpp
@@ -31,6 +31,7 @@ const char* getModuleName(Module mod)
 		case Module::DB:			return "DB";
 		case Module::DBUPDATER:		return "DB UPDATER";
 		case Module::FEATURE:		return "FEATURE";
+		case Module::FEEDBACK:		return "FEEDBACK";
 		case Module::HTTP:			return "HTTP";
 		case Module::MAIN:			return "MAIN";
 		case Module::METADATA:		return "METADATA";
diff --git a/src/libs/utils/impl/UUID.cpp b/src/libs/utils/impl/UUID.cpp
index 93f30d34..096ca0e5 100644
--- a/src/libs/utils/impl/UUID.cpp
+++ b/src/libs/utils/impl/UUID.cpp
@@ -19,40 +19,71 @@
 
 #include "utils/UUID.hpp"
 
+#include <cassert>
+#include <iomanip>
 #include <regex>
+#include <sstream>
 
+#include "utils/Random.hpp"
 #include "utils/String.hpp"
 
 namespace StringUtils
 {
-	template <>
-	std::optional<UUID>
-	readAs(std::string_view str)
-	{
-		return UUID::fromString(str);
-	}
+    template <>
+    std::optional<UUID>
+        readAs(std::string_view str)
+    {
+        return UUID::fromString(str);
+    }
 }
-
-static
-bool
-stringIsUUID(std::string_view str)
+namespace
 {
-	static const std::regex re { R"([0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12})"};
+    bool stringIsUUID(std::string_view str)
+    {
+        static const std::regex re{ R"([0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12})" };
 
-	return std::regex_match(std::cbegin(str), std::cend(str), re);
+        return std::regex_match(std::cbegin(str), std::cend(str), re);
+    }
 }
 
 UUID::UUID(std::string_view str)
-	: _value {StringUtils::stringToLower(str)}
+    : _value{ StringUtils::stringToLower(str) }
 {
 }
 
-std::optional<UUID>
-UUID::fromString(std::string_view str)
+std::optional<UUID> UUID::fromString(std::string_view str)
 {
-	if (!stringIsUUID(str))
-		return std::nullopt;
+    if (!stringIsUUID(str))
+        return std::nullopt;
 
-	return UUID {str};
+    return UUID{ str };
+}
+
+UUID UUID::generate()
+{
+    // Form is "123e4567-e89b-12d3-a456-426614174000"
+    // TODO: store 128 bits and only convert to string when necessary
+
+    std::ostringstream oss;
+
+    auto concatRandomBytes{ [](std::ostream& os, std::size_t byteCount)
+    {
+        for (std::size_t i {}; i < byteCount; ++i)
+            os << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(Random::getRandom<std::uint8_t>(0, 255));
+    } };
+
+    concatRandomBytes(oss, 4);
+    oss << "-";
+    concatRandomBytes(oss, 2);
+    oss << "-";
+    concatRandomBytes(oss, 2);
+    oss << "-";
+    concatRandomBytes(oss, 2);
+    oss << "-";
+    concatRandomBytes(oss, 6);
+
+    const auto uuid{fromString(oss.str())};
+    assert(uuid);
+    return uuid.value();
 }
 
diff --git a/src/libs/utils/include/utils/Logger.hpp b/src/libs/utils/include/utils/Logger.hpp
index ba36f4ea..f7a48916 100644
--- a/src/libs/utils/include/utils/Logger.hpp
+++ b/src/libs/utils/include/utils/Logger.hpp
@@ -43,6 +43,7 @@ enum class Module
     DB,
     DBUPDATER,
     FEATURE,
+    FEEDBACK,
     HTTP,
     MAIN,
     METADATA,
diff --git a/src/libs/utils/include/utils/UUID.hpp b/src/libs/utils/include/utils/UUID.hpp
index 9d4ee2f2..2507965c 100644
--- a/src/libs/utils/include/utils/UUID.hpp
+++ b/src/libs/utils/include/utils/UUID.hpp
@@ -27,20 +27,21 @@
 
 class UUID
 {
-	public:
-		static std::optional<UUID> fromString(std::string_view str);
+public:
+    static std::optional<UUID> fromString(std::string_view str);
+    static UUID generate();
 
-		std::string_view getAsString() const { return _value; }
+    std::string_view getAsString() const { return _value; }
 
-	private:
-		UUID(std::string_view value);
-		std::string _value;
+private:
+    UUID(std::string_view value);
+    std::string _value;
 };
 
 namespace StringUtils
 {
-	template <>
-	std::optional<UUID>
-	readAs(std::string_view str);
+    template <>
+    std::optional<UUID>
+        readAs(std::string_view str);
 }
 
diff --git a/src/lms/CMakeLists.txt b/src/lms/CMakeLists.txt
index 482247fa..b42f9023 100644
--- a/src/lms/CMakeLists.txt
+++ b/src/lms/CMakeLists.txt
@@ -57,6 +57,7 @@ target_link_libraries(lms PRIVATE
 	lmsav
 	lmsauth
 	lmsdatabase
+	lmsfeedback
 	lmsrecommendation
 	lmsscanner
 	lmsscrobbling
diff --git a/src/lms/main.cpp b/src/lms/main.cpp
index 0dd1fe41..543c2475 100644
--- a/src/lms/main.cpp
+++ b/src/lms/main.cpp
@@ -32,6 +32,7 @@
 #include "services/cover/ICoverService.hpp"
 #include "services/database/Db.hpp"
 #include "services/database/Session.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "services/recommendation/IPlaylistGeneratorService.hpp"
 #include "services/recommendation/IRecommendationService.hpp"
 #include "services/scanner/IScannerService.hpp"
@@ -50,84 +51,84 @@ static
 std::size_t
 getThreadCount()
 {
-	const unsigned long configHttpServerThreadCount {Service<IConfig>::get()->getULong("http-server-thread-count", 0)};
+    const unsigned long configHttpServerThreadCount{ Service<IConfig>::get()->getULong("http-server-thread-count", 0) };
 
-	// Reserve at least 2 threads since we still have some blocking IO (for example when reading from ffmpeg)
-	return configHttpServerThreadCount ? configHttpServerThreadCount : std::max<unsigned long>(2, std::thread::hardware_concurrency());
+    // Reserve at least 2 threads since we still have some blocking IO (for example when reading from ffmpeg)
+    return configHttpServerThreadCount ? configHttpServerThreadCount : std::max<unsigned long>(2, std::thread::hardware_concurrency());
 }
 
 static
 std::vector<std::string>
 generateWtConfig(std::string execPath)
 {
-	std::vector<std::string> args;
+    std::vector<std::string> args;
 
-	const std::filesystem::path wtConfigPath {Service<IConfig>::get()->getPath("working-dir") / "wt_config.xml"};
-	const std::filesystem::path wtLogFilePath {Service<IConfig>::get()->getPath("log-file", "/var/log/lms.log")};
-	const std::filesystem::path wtAccessLogFilePath {Service<IConfig>::get()->getPath("access-log-file", "/var/log/lms.access.log")};
-	const std::filesystem::path wtResourcesPath {Service<IConfig>::get()->getPath("wt-resources", "/usr/share/Wt/resources")};
+    const std::filesystem::path wtConfigPath{ Service<IConfig>::get()->getPath("working-dir") / "wt_config.xml" };
+    const std::filesystem::path wtLogFilePath{ Service<IConfig>::get()->getPath("log-file", "/var/log/lms.log") };
+    const std::filesystem::path wtAccessLogFilePath{ Service<IConfig>::get()->getPath("access-log-file", "/var/log/lms.access.log") };
+    const std::filesystem::path wtResourcesPath{ Service<IConfig>::get()->getPath("wt-resources", "/usr/share/Wt/resources") };
 
-	args.push_back(execPath);
-	args.push_back("--config=" + wtConfigPath.string());
-	args.push_back("--docroot=" + std::string {Service<IConfig>::get()->getString("docroot")});
-	args.push_back("--approot=" + std::string {Service<IConfig>::get()->getString("approot")});
-	args.push_back("--deploy-path=" + std::string {Service<IConfig>::get()->getString("deploy-path", "/")});
-	if (!wtResourcesPath.empty())
-		args.push_back("--resources-dir=" + wtResourcesPath.string());
+    args.push_back(execPath);
+    args.push_back("--config=" + wtConfigPath.string());
+    args.push_back("--docroot=" + std::string{ Service<IConfig>::get()->getString("docroot") });
+    args.push_back("--approot=" + std::string{ Service<IConfig>::get()->getString("approot") });
+    args.push_back("--deploy-path=" + std::string{ Service<IConfig>::get()->getString("deploy-path", "/") });
+    if (!wtResourcesPath.empty())
+        args.push_back("--resources-dir=" + wtResourcesPath.string());
 
-	if (Service<IConfig>::get()->getBool("tls-enable", false))
-	{
-		args.push_back("--https-port=" + std::to_string( Service<IConfig>::get()->getULong("listen-port", 5082)));
-		args.push_back("--https-address=" + std::string {Service<IConfig>::get()->getString("listen-addr", "0.0.0.0")});
-		args.push_back("--ssl-certificate=" + std::string {Service<IConfig>::get()->getString("tls-cert")});
-		args.push_back("--ssl-private-key=" + std::string {Service<IConfig>::get()->getString("tls-key")});
-		args.push_back("--ssl-tmp-dh=" + std::string {Service<IConfig>::get()->getString("tls-dh")});
-	}
-	else
-	{
-		args.push_back("--http-port=" + std::to_string( Service<IConfig>::get()->getULong("listen-port", 5082)));
-		args.push_back("--http-address=" + std::string {Service<IConfig>::get()->getString("listen-addr", "0.0.0.0")});
-	}
+    if (Service<IConfig>::get()->getBool("tls-enable", false))
+    {
+        args.push_back("--https-port=" + std::to_string(Service<IConfig>::get()->getULong("listen-port", 5082)));
+        args.push_back("--https-address=" + std::string{ Service<IConfig>::get()->getString("listen-addr", "0.0.0.0") });
+        args.push_back("--ssl-certificate=" + std::string{ Service<IConfig>::get()->getString("tls-cert") });
+        args.push_back("--ssl-private-key=" + std::string{ Service<IConfig>::get()->getString("tls-key") });
+        args.push_back("--ssl-tmp-dh=" + std::string{ Service<IConfig>::get()->getString("tls-dh") });
+    }
+    else
+    {
+        args.push_back("--http-port=" + std::to_string(Service<IConfig>::get()->getULong("listen-port", 5082)));
+        args.push_back("--http-address=" + std::string{ Service<IConfig>::get()->getString("listen-addr", "0.0.0.0") });
+    }
 
-	if (!wtAccessLogFilePath.empty())
-		args.push_back("--accesslog=" + wtAccessLogFilePath.string());
+    if (!wtAccessLogFilePath.empty())
+        args.push_back("--accesslog=" + wtAccessLogFilePath.string());
 
-	args.push_back("--threads=" + std::to_string(getThreadCount()));
+    args.push_back("--threads=" + std::to_string(getThreadCount()));
 
-	// Generate the wt_config.xml file
-	boost::property_tree::ptree pt;
+    // Generate the wt_config.xml file
+    boost::property_tree::ptree pt;
 
-	pt.put("server.application-settings.<xmlattr>.location", "*");
-	pt.put("server.application-settings.log-file", wtLogFilePath.string());
-	pt.put("server.application-settings.log-config", Service<IConfig>::get()->getString("log-config", "* -debug -info:WebRequest"));
-	pt.put("server.application-settings.behind-reverse-proxy", Service<IConfig>::get()->getBool("behind-reverse-proxy", false));
+    pt.put("server.application-settings.<xmlattr>.location", "*");
+    pt.put("server.application-settings.log-file", wtLogFilePath.string());
+    pt.put("server.application-settings.log-config", Service<IConfig>::get()->getString("log-config", "* -debug -info:WebRequest"));
+    pt.put("server.application-settings.behind-reverse-proxy", Service<IConfig>::get()->getBool("behind-reverse-proxy", false));
 
-	{
-		boost::property_tree::ptree viewport;
-		viewport.put("<xmlattr>.name", "viewport");
-		viewport.put("<xmlattr>.content", "width=device-width, initial-scale=1, user-scalable=no");
-		pt.add_child("server.application-settings.head-matter.meta", viewport);
-	}
-	{
-		boost::property_tree::ptree themeColor;
-		themeColor.put("<xmlattr>.name", "theme-color");
-		themeColor.put("<xmlattr>.content", "#303030");
-		pt.add_child("server.application-settings.head-matter.meta", themeColor);
-	}
+    {
+        boost::property_tree::ptree viewport;
+        viewport.put("<xmlattr>.name", "viewport");
+        viewport.put("<xmlattr>.content", "width=device-width, initial-scale=1, user-scalable=no");
+        pt.add_child("server.application-settings.head-matter.meta", viewport);
+    }
+    {
+        boost::property_tree::ptree themeColor;
+        themeColor.put("<xmlattr>.name", "theme-color");
+        themeColor.put("<xmlattr>.content", "#303030");
+        pt.add_child("server.application-settings.head-matter.meta", themeColor);
+    }
 
 
-	{
-		std::ofstream oss {wtConfigPath.string().c_str(), std::ios::out};
-		if (!oss)
-			throw LmsException {"Can't open '" + wtConfigPath.string() + "' for writing!"};
+    {
+        std::ofstream oss{ wtConfigPath.string().c_str(), std::ios::out };
+        if (!oss)
+            throw LmsException{ "Can't open '" + wtConfigPath.string() + "' for writing!" };
 
-		boost::property_tree::xml_parser::write_xml(oss, pt);
+        boost::property_tree::xml_parser::write_xml(oss, pt);
 
-		if (!oss)
-			throw LmsException {"Can't write in file '" + wtConfigPath.string() + "', no space left?"};
-	}
+        if (!oss)
+            throw LmsException{ "Can't write in file '" + wtConfigPath.string() + "', no space left?" };
+    }
 
-	return args;
+    return args;
 }
 
 
@@ -135,194 +136,195 @@ static
 void
 proxyScannerEventsToApplication(Scanner::IScannerService& scanner, Wt::WServer& server)
 {
-	auto postAll {[](Wt::WServer& server, std::function<void()> cb)
-	{
-		server.postAll([cb = std::move(cb)]
-		{
-			// may be nullptr, see https://redmine.webtoolkit.eu/issues/8202
-			if (LmsApp)
-				cb();
-		});
-	}};
+    auto postAll{ [](Wt::WServer& server, std::function<void()> cb)
+    {
+        server.postAll([cb = std::move(cb)]
+        {
+                // may be nullptr, see https://redmine.webtoolkit.eu/issues/8202
+                if (LmsApp)
+                    cb();
+            });
+        } };
 
-	scanner.getEvents().scanStarted.connect([&]
-	{
-		postAll(server, []
-		{
-			LmsApp->getScannerEvents().scanStarted.emit();
-			LmsApp->triggerUpdate();
-		});
-	});
+    scanner.getEvents().scanStarted.connect([&]
+        {
+            postAll(server, []
+                {
+                    LmsApp->getScannerEvents().scanStarted.emit();
+                    LmsApp->triggerUpdate();
+                });
+        });
 
-	scanner.getEvents().scanComplete.connect([&] (const Scanner::ScanStats& stats)
-	{
-		postAll(server, [=]
-		{
-			LmsApp->getScannerEvents().scanComplete.emit(stats);
-			LmsApp->triggerUpdate();
-		});
-	});
+    scanner.getEvents().scanComplete.connect([&](const Scanner::ScanStats& stats)
+        {
+            postAll(server, [=]
+                {
+                    LmsApp->getScannerEvents().scanComplete.emit(stats);
+                    LmsApp->triggerUpdate();
+                });
+        });
 
-	scanner.getEvents().scanInProgress.connect([&] (const Scanner::ScanStepStats& stats)
-	{
-		postAll(server, [=]
-		{
-			LmsApp->getScannerEvents().scanInProgress.emit(stats);
-			LmsApp->triggerUpdate();
-		});
-	});
+    scanner.getEvents().scanInProgress.connect([&](const Scanner::ScanStepStats& stats)
+        {
+            postAll(server, [=]
+                {
+                    LmsApp->getScannerEvents().scanInProgress.emit(stats);
+                    LmsApp->triggerUpdate();
+                });
+        });
 
-	scanner.getEvents().scanScheduled.connect([&] (const Wt::WDateTime dateTime)
-	{
-		postAll(server, [=]
-		{
-			LmsApp->getScannerEvents().scanScheduled.emit(dateTime);
-			LmsApp->triggerUpdate();
-		});
-	});
+    scanner.getEvents().scanScheduled.connect([&](const Wt::WDateTime dateTime)
+        {
+            postAll(server, [=]
+                {
+                    LmsApp->getScannerEvents().scanScheduled.emit(dateTime);
+                    LmsApp->triggerUpdate();
+                });
+        });
 }
 
 int main(int argc, char* argv[])
 {
-	std::filesystem::path configFilePath {"/etc/lms.conf"};
-	int res {EXIT_FAILURE};
+    std::filesystem::path configFilePath{ "/etc/lms.conf" };
+    int res{ EXIT_FAILURE };
 
-	assert(argc > 0);
-	assert(argv[0] != NULL);
+    assert(argc > 0);
+    assert(argv[0] != NULL);
 
-	if (argc == 2)
-		configFilePath = std::string(argv[1], 0, 256);
-	else if (argc > 2)
-	{
-		std::cerr << "Usage:\t" << argv[0] << "\t[conf_file]\n\n"
-			<< "Options:\n"
-			<< "\tconf_file:\t path to the LMS configuration file (defaults to " << configFilePath << ")\n\n";
-		return EXIT_FAILURE;
-	}
+    if (argc == 2)
+        configFilePath = std::string(argv[1], 0, 256);
+    else if (argc > 2)
+    {
+        std::cerr << "Usage:\t" << argv[0] << "\t[conf_file]\n\n"
+            << "Options:\n"
+            << "\tconf_file:\t path to the LMS configuration file (defaults to " << configFilePath << ")\n\n";
+        return EXIT_FAILURE;
+    }
 
-	try
-	{
-		close(STDIN_FILENO);
+    try
+    {
+        close(STDIN_FILENO);
 
-		Service<IConfig> config {createConfig(configFilePath)};
-		Service<Logger> logger {std::make_unique<WtLogger>()};
+        Service<IConfig> config{ createConfig(configFilePath) };
+        Service<Logger> logger{ std::make_unique<WtLogger>() };
 
-		// use system locale. libarchive relies on this to write filenames
-		if (char *locale {::setlocale(LC_ALL, "")})
-			LMS_LOG(MAIN, INFO) << "locale set to '" << locale << "'";
-		else
-			LMS_LOG(MAIN, WARNING) << "Cannot set locale from system";
+        // use system locale. libarchive relies on this to write filenames
+        if (char* locale{ ::setlocale(LC_ALL, "") })
+            LMS_LOG(MAIN, INFO) << "locale set to '" << locale << "'";
+        else
+            LMS_LOG(MAIN, WARNING) << "Cannot set locale from system";
 
-		// Make sure the working directory exists
-		std::filesystem::create_directories(config->getPath("working-dir"));
-		std::filesystem::create_directories(config->getPath("working-dir") / "cache");
+        // Make sure the working directory exists
+        std::filesystem::create_directories(config->getPath("working-dir"));
+        std::filesystem::create_directories(config->getPath("working-dir") / "cache");
 
-		// Construct WT configuration and get the argc/argv back
-		const std::vector<std::string> wtServerArgs {generateWtConfig(argv[0])};
+        // Construct WT configuration and get the argc/argv back
+        const std::vector<std::string> wtServerArgs{ generateWtConfig(argv[0]) };
 
-		std::vector<const char*> wtArgv(wtServerArgs.size());
-		for (std::size_t i = 0; i < wtServerArgs.size(); ++i)
-		{
-			std::cout << "ARG = " << wtServerArgs[i] << std::endl;
-			wtArgv[i] = wtServerArgs[i].c_str();
-		}
+        std::vector<const char*> wtArgv(wtServerArgs.size());
+        for (std::size_t i = 0; i < wtServerArgs.size(); ++i)
+        {
+            std::cout << "ARG = " << wtServerArgs[i] << std::endl;
+            wtArgv[i] = wtServerArgs[i].c_str();
+        }
 
-		boost::asio::io_context ioContext; // ioContext used to dispatch all the services that are out of the Wt event loop
-		Wt::WServer server {argv[0]};
-		server.setServerConfiguration(wtServerArgs.size(), const_cast<char**>(&wtArgv[0]));
+        boost::asio::io_context ioContext; // ioContext used to dispatch all the services that are out of the Wt event loop
+        Wt::WServer server{ argv[0] };
+        server.setServerConfiguration(wtServerArgs.size(), const_cast<char**>(&wtArgv[0]));
 
-		IOContextRunner ioContextRunner {ioContext, getThreadCount()};
+        IOContextRunner ioContextRunner{ ioContext, getThreadCount() };
 
-		// Initializing a connection pool to the database that will be shared along services
-		Database::Db database {config->getPath("working-dir") / "lms.db", getThreadCount()};
-		{
-			Database::Session session {database};
-			session.prepareTables();
+        // Initializing a connection pool to the database that will be shared along services
+        Database::Db database{ config->getPath("working-dir") / "lms.db", getThreadCount() };
+        {
+            Database::Session session{ database };
+            session.prepareTables();
 
-			 // force optimize in case scanner aborted during a large import:
-			 // queries may be too slow to even be able to relaunch a scan sing the web interface
-			session.analyze();
-		}
+            // force optimize in case scanner aborted during a large import:
+            // queries may be too slow to even be able to relaunch a scan sing the web interface
+            session.analyze();
+        }
 
-		UserInterface::LmsApplicationManager appManager;
+        UserInterface::LmsApplicationManager appManager;
 
-		// Service initialization order is important (reverse-order for deinit)
-		Service<IChildProcessManager> childProcessManagerService {createChildProcessManager(ioContext)};
-		Service<Auth::IAuthTokenService> authTokenService;
-		Service<Auth::IPasswordService> authPasswordService;
-		Service<Auth::IEnvService> authEnvService;
+        // Service initialization order is important (reverse-order for deinit)
+        Service<IChildProcessManager> childProcessManagerService{ createChildProcessManager(ioContext) };
+        Service<Auth::IAuthTokenService> authTokenService;
+        Service<Auth::IPasswordService> authPasswordService;
+        Service<Auth::IEnvService> authEnvService;
 
-		const std::string authenticationBackend {StringUtils::stringToLower(config->getString("authentication-backend", "internal"))};
-		if (authenticationBackend == "internal" || authenticationBackend == "pam")
-		{
-			authTokenService.assign(Auth::createAuthTokenService(database, config->getULong("login-throttler-max-entriees", 10000)));
-			authPasswordService.assign(Auth::createPasswordService(authenticationBackend, database, config->getULong("login-throttler-max-entriees", 10000), *authTokenService.get()));
-		}
-		else if (authenticationBackend == "http-headers")
-		{
-			authEnvService.assign(Auth::createEnvService(authenticationBackend, database));
-		}
-		else
-			throw LmsException {"Bad value '" + authenticationBackend + "' for 'authentication-backend'"};
+        const std::string authenticationBackend{ StringUtils::stringToLower(config->getString("authentication-backend", "internal")) };
+        if (authenticationBackend == "internal" || authenticationBackend == "pam")
+        {
+            authTokenService.assign(Auth::createAuthTokenService(database, config->getULong("login-throttler-max-entriees", 10000)));
+            authPasswordService.assign(Auth::createPasswordService(authenticationBackend, database, config->getULong("login-throttler-max-entriees", 10000), *authTokenService.get()));
+        }
+        else if (authenticationBackend == "http-headers")
+        {
+            authEnvService.assign(Auth::createEnvService(authenticationBackend, database));
+        }
+        else
+            throw LmsException{ "Bad value '" + authenticationBackend + "' for 'authentication-backend'" };
 
-		Image::init(argv[0]);
-		Service<Cover::ICoverService> coverService {Cover::createCoverService(database, argv[0], server.appRoot() + "/images/unknown-cover.jpg")};
-		Service<Recommendation::IRecommendationService> recommendationService {Recommendation::createRecommendationService(database)};
-		Service<Recommendation::IPlaylistGeneratorService> playlistGeneratorService {Recommendation::createPlaylistGeneratorService(database, *recommendationService.get())};
-		Service<Scanner::IScannerService> scannerService {Scanner::createScannerService(database, *recommendationService)};
+        Image::init(argv[0]);
+        Service<Cover::ICoverService> coverService{ Cover::createCoverService(database, argv[0], server.appRoot() + "/images/unknown-cover.jpg") };
+        Service<Recommendation::IRecommendationService> recommendationService{ Recommendation::createRecommendationService(database) };
+        Service<Recommendation::IPlaylistGeneratorService> playlistGeneratorService{ Recommendation::createPlaylistGeneratorService(database, *recommendationService.get()) };
+        Service<Scanner::IScannerService> scannerService{ Scanner::createScannerService(database, *recommendationService) };
 
-		scannerService->getEvents().scanComplete.connect([&]
-		{
-			// Flush cover cache even if no changes:
-			// covers may be external files that changed and we don't keep track of them
-			coverService->flushCache();
-		});
+        scannerService->getEvents().scanComplete.connect([&]
+            {
+                // Flush cover cache even if no changes:
+                // covers may be external files that changed and we don't keep track of them
+                coverService->flushCache();
+            });
 
-		Service<Scrobbling::IScrobblingService> scrobblingService {Scrobbling::createScrobblingService(ioContext, database)};
+        Service<Feedback::IFeedbackService> feedbackService{ Feedback::createFeedbackService(ioContext, database) };
+        Service<Scrobbling::IScrobblingService> scrobblingService{ Scrobbling::createScrobblingService(ioContext, database) };
 
-		std::unique_ptr<Wt::WResource> subsonicResource;
+        std::unique_ptr<Wt::WResource> subsonicResource;
 
-		// bind API resources
-		if (config->getBool("api-subsonic", true))
-		{
-			subsonicResource = API::Subsonic::createSubsonicResource(database);
-			server.addResource(subsonicResource.get(), "/rest");
-		}
+        // bind API resources
+        if (config->getBool("api-subsonic", true))
+        {
+            subsonicResource = API::Subsonic::createSubsonicResource(database);
+            server.addResource(subsonicResource.get(), "/rest");
+        }
 
-		// bind UI entry point
-		server.addEntryPoint(Wt::EntryPointType::Application,
-			[&](const Wt::WEnvironment &env)
-			{
-				return UserInterface::LmsApplication::create(env, database, appManager);
-			});
+        // bind UI entry point
+        server.addEntryPoint(Wt::EntryPointType::Application,
+            [&](const Wt::WEnvironment& env)
+            {
+                return UserInterface::LmsApplication::create(env, database, appManager);
+            });
 
-		proxyScannerEventsToApplication(*scannerService, server);
+        proxyScannerEventsToApplication(*scannerService, server);
 
-		LMS_LOG(MAIN, INFO) << "Starting server...";
-		server.start();
+        LMS_LOG(MAIN, INFO) << "Starting server...";
+        server.start();
 
-		LMS_LOG(MAIN, INFO) << "Now running...";
-		Wt::WServer::waitForShutdown();
+        LMS_LOG(MAIN, INFO) << "Now running...";
+        Wt::WServer::waitForShutdown();
 
-		LMS_LOG(MAIN, INFO) << "Stopping server...";
-		server.stop();
+        LMS_LOG(MAIN, INFO) << "Stopping server...";
+        server.stop();
 
-		LMS_LOG(MAIN, INFO) << "Quitting...";
-		res = EXIT_SUCCESS;
-	}
-	catch (const Wt::WServer::Exception& e)
-	{
-		LMS_LOG(MAIN, FATAL) << "Caught WServer::Exception: " << e.what();
-		std::cerr << "Caught a WServer::Exception: " << e.what() << std::endl;
-		res = EXIT_FAILURE;
-	}
-	catch (const std::exception& e)
-	{
-		LMS_LOG(MAIN, FATAL) << "Caught std::exception: " << e.what();
-		std::cerr << "Caught std::exception: " << e.what() << std::endl;
-		res = EXIT_FAILURE;
-	}
+        LMS_LOG(MAIN, INFO) << "Quitting...";
+        res = EXIT_SUCCESS;
+    }
+    catch (const Wt::WServer::Exception& e)
+    {
+        LMS_LOG(MAIN, FATAL) << "Caught WServer::Exception: " << e.what();
+        std::cerr << "Caught a WServer::Exception: " << e.what() << std::endl;
+        res = EXIT_FAILURE;
+    }
+    catch (const std::exception& e)
+    {
+        LMS_LOG(MAIN, FATAL) << "Caught std::exception: " << e.what();
+        std::cerr << "Caught std::exception: " << e.what() << std::endl;
+        res = EXIT_FAILURE;
+    }
 
-	return res;
+    return res;
 }
 
diff --git a/src/lms/ui/PlayQueue.cpp b/src/lms/ui/PlayQueue.cpp
index 1df4bc79..fab4cc70 100644
--- a/src/lms/ui/PlayQueue.cpp
+++ b/src/lms/ui/PlayQueue.cpp
@@ -34,7 +34,7 @@
 #include "services/database/Track.hpp"
 #include "services/database/TrackList.hpp"
 #include "services/database/User.hpp"
-#include "services/scrobbling/IScrobblingService.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "services/recommendation/IPlaylistGeneratorService.hpp"
 #include "utils/IConfig.hpp"
 #include "utils/Logger.hpp"
@@ -51,788 +51,756 @@
 #include "ModalManager.hpp"
 #include "Utils.hpp"
 
-namespace UserInterface {
-
-namespace
+namespace UserInterface
 {
-	class CreateTrackListModel : public Wt::WFormModel
-	{
-		public:
-			static inline const Field NameField {"name"};
-
-			CreateTrackListModel()
-			{
-				addField(NameField);
-				setValidator(NameField, createMandatoryValidator());
-			}
-
-			Wt::WString getName() const { return valueText(NameField); }
-	};
-
-	class ReplaceTrackListModel : public Wt::WFormModel
-	{
-		public:
-			static inline const Field NameField {"name"};
-			using TrackListModel = ValueStringModel<Database::TrackListId>;
-
-			ReplaceTrackListModel()
-			{
-				addField(NameField);
-				setValidator(NameField, createMandatoryValidator());
-			}
-
-			Database::TrackListId getTrackListId() const
-			{
-				auto row {trackListModel->getRowFromString(valueText(NameField))};
-				return trackListModel->getValue(*row);
-			}
-
-			static
-			std::shared_ptr<TrackListModel>
-			createTrackListModel()
-			{
-				using namespace Database;
-
-				auto model {std::make_shared<TrackListModel>()};
-
-				auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-
-				TrackList::FindParameters params;
-				params.setType(TrackListType::Playlist);
-				params.setUser(LmsApp->getUserId());
-				params.setSortMethod(TrackListSortMethod::Name);
-
-				auto tracklists {TrackList::find(LmsApp->getDbSession(), params)};
-				for (const TrackListId trackListId : tracklists.results)
-				{
-					const TrackList::pointer trackList {TrackList::find(LmsApp->getDbSession(), trackListId)};
-					model->add(Wt::WString::fromUTF8(std::string {trackList->getName()}), trackListId);
-				}
-
-				return model;
-			}
-
-			std::shared_ptr<TrackListModel> trackListModel {createTrackListModel()};
-	};
-}
-
-PlayQueue::PlayQueue()
-: Template {Wt::WString::tr("Lms.PlayQueue.template")}
-, _capacity {Service<IConfig>::get()->getULong("playqueue-max-entry-count", 1000)}
-{
-	initTrackLists();
-
-	addFunction("id", &Wt::WTemplate::Functions::id);
-	addFunction("tr", &Wt::WTemplate::Functions::tr);
-
-	Wt::WPushButton* clearBtn {bindNew<Wt::WPushButton>("clear-btn", Wt::WString::tr("Lms.PlayQueue.template.clear-btn"), Wt::TextFormat::XHTML)};
-	clearBtn->clicked().connect([=]
-	{
-		clearTracks();
-	});
-
-	Wt::WPushButton* saveBtn {bindNew<Wt::WPushButton>("save-btn", Wt::WString::tr("Lms.PlayQueue.template.save-btn"), Wt::TextFormat::XHTML)};
-	saveBtn->clicked().connect([=]
-	{
-		saveAsTrackList();
-	});
-
-	_entriesContainer = bindNew<InfiniteScrollingContainer>("entries", Wt::WString::tr("Lms.PlayQueue.template.entry-container"));
-	_entriesContainer->onRequestElements.connect([this]
-	{
-		addSome();
-		updateCurrentTrack(true);
-	});
-
-	Wt::WPushButton* shuffleBtn {bindNew<Wt::WPushButton>("shuffle-btn", Wt::WString::tr("Lms.PlayQueue.template.shuffle-btn"), Wt::TextFormat::XHTML)};
-	shuffleBtn->clicked().connect([=]
-	{
-		{
-			auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
-
-			Database::TrackList::pointer queue {getQueue()};
-			auto entries {queue->getEntries()};
-			Random::shuffleContainer(entries);
-
-			queue.modify()->clear();
-			for (const Database::TrackListEntry::pointer& entry : entries)
-				LmsApp->getDbSession().create<Database::TrackListEntry>(entry->getTrack(), queue);
-		}
-		_entriesContainer->reset();
-		addSome();
-	});
-
-	_repeatBtn = bindNew<Wt::WCheckBox>("repeat-btn");
-	_repeatBtn->clicked().connect([=]
-	{
-		auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
-
-		if (!LmsApp->getUser()->isDemo())
-			LmsApp->getUser().modify()->setRepeatAll(isRepeatAllSet());
-	});
-	{
-		auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-		if (LmsApp->getUser()->isRepeatAllSet())
-			_repeatBtn->setCheckState(Wt::CheckState::Checked);
-	}
-
-	_radioBtn = bindNew<Wt::WCheckBox>("radio-btn");
-	_radioBtn->clicked().connect([=]
-	{
-		{
-			auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
-
-			if (!LmsApp->getUser()->isDemo())
-				LmsApp->getUser().modify()->setRadio(isRadioModeSet());
-		}
-		if (isRadioModeSet())
-			enqueueRadioTracksIfNeeded();
-	});
-
-	bool isRadioModeSet {};
-	{
-		auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-		isRadioModeSet = LmsApp->getUser()->isRadioSet();
-	}
-	if (isRadioModeSet)
-	{
-		_radioBtn->setCheckState(Wt::CheckState::Checked);
-		enqueueRadioTracksIfNeeded();
-	}
-
-	_nbTracks = bindNew<Wt::WText>("track-count");
-	_duration = bindNew<Wt::WText>("duration");
-
-	LmsApp->getMediaPlayer().settingsLoaded.connect([=]
-	{
-		if (_mediaPlayerSettingsLoaded)
-			return;
-
-		_mediaPlayerSettingsLoaded = true;
-
-		std::size_t trackPos {};
-
-		{
-			auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-			trackPos = LmsApp->getUser()->getCurPlayingTrackPos();
-		}
-
-		loadTrack(trackPos, false);
-	});
-
-	LmsApp->preQuit().connect([=]
-	{
-		auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
-
-		if (LmsApp->getUser()->isDemo())
-		{
-			LMS_LOG(UI, DEBUG) << "Removing queue (tracklist id " << _queueId.toString() << ")";
-			if (Database::TrackList::pointer queue {getQueue()})
-				queue.remove();
-		}
-	});
-
-	updateInfo();
-}
-
-bool
-PlayQueue::isRepeatAllSet() const
-{
-	return _repeatBtn->checkState() == Wt::CheckState::Checked;
-}
-
-bool
-PlayQueue::isRadioModeSet() const
-{
-	return _radioBtn->checkState() == Wt::CheckState::Checked;
-}
-
-Database::TrackList::pointer
-PlayQueue::getQueue() const
-{
-	return Database::TrackList::find(LmsApp->getDbSession(), _queueId);
-}
-
-bool
-PlayQueue::isFull() const
-{
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-	return getQueue()->getCount() == getCapacity();
-}
-
-void
-PlayQueue::clearTracks()
-{
-	{
-		auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
-		getQueue().modify()->clear();
-	}
-
-	_entriesContainer->reset();
-	_trackPos.reset();
-	updateInfo();
-}
-
-void
-PlayQueue::stop()
-{
-	updateCurrentTrack(false);
-	_trackPos.reset();
-	_isTrackSelected = false;
-	trackUnselected.emit();
-}
-
-void
-PlayQueue::loadTrack(std::size_t pos, bool play)
-{
-	updateCurrentTrack(false);
-
-	Database::TrackId trackId {};
-	std::optional<float> replayGain {};
-	{
-		auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-
-		const Database::TrackList::pointer queue {getQueue()};
-
-		// If out of range, stop playing
-		if (pos >= queue->getCount())
-		{
-			if (!isRepeatAllSet() || queue->getCount() == 0)
-			{
-				stop();
-				return;
-			}
-
-			pos = 0;
-		}
-
-		_trackPos = pos;
-		const Database::Track::pointer track {queue->getEntry(*_trackPos)->getTrack()};
-
-		trackId = track->getId();
-
-		replayGain = getReplayGain(pos, track);
-
-		if (!LmsApp->getUser()->isDemo())
-			LmsApp->getUser().modify()->setCurPlayingTrackPos(pos);
-	}
-
-	enqueueRadioTracksIfNeeded();
-	updateCurrentTrack(true);
-	_isTrackSelected = true;
-	trackSelected.emit(trackId, play, replayGain ? *replayGain : 0);
-}
-
-void
-PlayQueue::playPrevious()
-{
-	if (!_trackPos)
-		return;
-
-	if (*_trackPos == 0)
-		stop();
-	else
-		loadTrack(*_trackPos - 1, true);
-}
-
-void
-PlayQueue::playNext()
-{
-	if (!_trackPos)
-	{
-		loadTrack(0, true);
-		return;
-	}
-
-	loadTrack(*_trackPos + 1, true);
-}
-
-void
-PlayQueue::onPlaybackEnded()
-{
-	playNext();
-}
-
-std::size_t
-PlayQueue::getCount()
-{
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-	return getQueue()->getCount();
-}
-
-void
-PlayQueue::initTrackLists()
-{
-	auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
-
-	Database::TrackList::pointer queue;
-	Database::TrackList::pointer radioStartingTracks;
-
-	if (!LmsApp->getUser()->isDemo())
-	{
-		static const std::string queueName {"__queued_tracks__"};
-		queue = Database::TrackList::find(LmsApp->getDbSession(), queueName, Database::TrackListType::Internal, LmsApp->getUserId());
-		if (!queue)
-			queue = LmsApp->getDbSession().create<Database::TrackList>(queueName, Database::TrackListType::Internal, false, LmsApp->getUser());
-	}
-	else
-	{
-		static const std::string queueName {"__temp_queue__"};
-		queue = LmsApp->getDbSession().create<Database::TrackList>(queueName, Database::TrackListType::Internal, false, LmsApp->getUser());
-	}
-
-	_queueId = queue->getId();
-}
-
-void
-PlayQueue::updateInfo()
-{
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-
-	const Database::TrackList::pointer queue {getQueue()};
-	const std::size_t trackCount {queue->getCount()};
-	_nbTracks->setText(Wt::WString::trn("Lms.track-count", trackCount).arg(trackCount));
-	_duration->setText(Utils::durationToString(queue->getDuration()));
-	trackCountChanged.emit(trackCount);
-}
-
-void
-PlayQueue::updateCurrentTrack(bool selected)
-{
-	if (!_trackPos || *_trackPos >= static_cast<std::size_t>(_entriesContainer->getCount()))
-		return;
-
-	Template* entry {static_cast<Template*>(_entriesContainer->getWidget(*_trackPos))};
-	if (!entry)
-		return;
-
-	entry->toggleStyleClass("Lms-entry-playing", selected);
-}
-
-void
-PlayQueue::enqueueTracks(const std::vector<Database::TrackId>& trackIds)
-{
-	{
-		auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
-
-		Database::TrackList::pointer queue {getQueue()};
-		const std::size_t queueSize {queue->getCount()};
-
-		std::size_t nbTracksToEnqueue {queueSize + trackIds.size() > getCapacity() ? getCapacity() - queueSize : trackIds.size()};
-		for (const Database::TrackId trackId : trackIds)
-		{
-			if (nbTracksToEnqueue == 0)
-				break;
-
-			Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), trackId)};
-			if (!track)
-				continue;
-
-			LmsApp->getDbSession().create<Database::TrackListEntry>(track, queue);
-			nbTracksToEnqueue--;
-		}
-	}
-
-	updateInfo();
-	addSome();
-	_entriesContainer->setHasMore();
-}
-
-std::vector<Database::TrackId>
-PlayQueue::getAndClearNextTracks()
-{
-	std::vector<Database::TrackId> tracks;
-
-	auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
-
-	Database::TrackList::pointer queue {getQueue()};
-	std::vector<Database::TrackListEntry::pointer> entries {queue->getEntries(Database::Range {_trackPos ? *_trackPos + 1 : 0, getCapacity()})};
-	tracks.reserve(entries.size());
-	for (Database::TrackListEntry::pointer entry : entries)
-	{
-		tracks.push_back(entry->getTrack()->getId());
-		entry.remove();
-	}
-
-	if (_trackPos)
-	{
-		// entries may have been cleared
-		if (*_trackPos + 1 < _entriesContainer->getCount())
-			_entriesContainer->remove(*_trackPos + 1, _entriesContainer->getCount() - 1);
-	}
-	else
-	{
-		_entriesContainer->reset();
-	}
-
-	return tracks;
-}
-
-void
-PlayQueue::play(const std::vector<Database::TrackId>& trackIds)
-{
-	playAtIndex(trackIds, 0);
-}
-
-void
-PlayQueue::playNext(const std::vector<Database::TrackId>& trackIds)
-{
-	std::vector<Database::TrackId> nextTracks {getAndClearNextTracks()};
-	nextTracks.insert(std::cbegin(nextTracks), std::cbegin(trackIds), std::cend(trackIds));
-	playOrAddLast(nextTracks);
-}
-
-void
-PlayQueue::playShuffled(const std::vector<Database::TrackId>& trackIds)
-{
-	clearTracks();
-	std::vector<Database::TrackId> shuffledTrackIds {trackIds};
-	Random::shuffleContainer(shuffledTrackIds);
-	enqueueTracks(shuffledTrackIds);
-	loadTrack(0, true);
-}
-
-void
-PlayQueue::playOrAddLast(const std::vector<Database::TrackId>& trackIds)
-{
-	enqueueTracks(trackIds);
-	if (!_isTrackSelected)
-		loadTrack(0, true);
-}
-
-void
-PlayQueue::playAtIndex(const std::vector<Database::TrackId>& trackIds, std::size_t index)
-{
-	clearTracks();
-	enqueueTracks(trackIds);
-	loadTrack(index, true);
-}
-
-void
-PlayQueue::addSome()
-{
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-
-	const Database::TrackList::pointer queue {getQueue()};
-	const auto tracklistEntries {queue->getEntries(Database::Range {_entriesContainer->getCount(), _batchSize})};
-	for (const Database::TrackListEntry::pointer& tracklistEntry : tracklistEntries)
-		addEntry(tracklistEntry);
-}
-
-void
-PlayQueue::addEntry(const Database::TrackListEntry::pointer& tracklistEntry)
-{
-	const Database::TrackListEntryId tracklistEntryId {tracklistEntry->getId()};
-	const auto track {tracklistEntry->getTrack()};
-	const Database::TrackId trackId {track->getId()};
-
-	Template* entry {_entriesContainer->addNew<Template>(Wt::WString::tr("Lms.PlayQueue.template.entry"))};
-	entry->addFunction("id", &Wt::WTemplate::Functions::id);
-
-	entry->bindString("name", Wt::WString::fromUTF8(track->getName()), Wt::TextFormat::Plain);
-
-	const auto artists {track->getArtistIds({Database::TrackArtistLinkType::Artist})};
-	if (!artists.empty())
-	{
-		entry->setCondition("if-has-artists", true);
-		entry->bindWidget("artists", Utils::createArtistAnchorList(artists));
-		entry->bindWidget("artists-md", Utils::createArtistAnchorList(artists));
-	}
-
-	const auto release {track->getRelease()};
-	if (release)
-	{
-		entry->setCondition("if-has-release", true);
-		entry->bindWidget("release", Utils::createReleaseAnchor(release));
-		{
-			Wt::WAnchor* anchor {entry->bindWidget("cover", Utils::createReleaseAnchor(release, false))};
-			auto cover {Utils::createCover(release->getId(), CoverResource::Size::Small)};
-			cover->addStyleClass("Lms-cover-track Lms-cover-anchor"); // HACK
-			anchor->setImage(std::move(cover));
-		}
-	}
-	else
-	{
-		auto cover {entry->bindWidget<Wt::WImage>("cover", Utils::createCover(track->getId(), CoverResource::Size::Small))};
-		cover->addStyleClass("Lms-cover-track");
-	}
-
-	entry->bindString("duration", Utils::durationToString(track->getDuration()), Wt::TextFormat::Plain);
-
-	Wt::WPushButton* playBtn {entry->bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.template.play-btn"), Wt::TextFormat::XHTML)};
-	playBtn->clicked().connect([=]
-	{
-		const std::optional<std::size_t> pos {_entriesContainer->getIndexOf(*entry)};
-		if (pos)
-			loadTrack(*pos, true);
-	});
-
-	Wt::WPushButton* delBtn {entry->bindNew<Wt::WPushButton>("del-btn", Wt::WString::tr("Lms.template.delete-btn"), Wt::TextFormat::XHTML)};
-	delBtn->setToolTip(Wt::WString::tr("Lms.delete"));
-	delBtn->clicked().connect([=]
-	{
-		// Remove the entry n both the widget tree and the playqueue
-		{
-			auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
-
-			Database::TrackListEntry::pointer entryToRemove {Database::TrackListEntry::getById(LmsApp->getDbSession(), tracklistEntryId)};
-			entryToRemove.remove();
-		}
-
-		if (_trackPos)
-		{
-			const std::optional<std::size_t> pos {_entriesContainer->getIndexOf(*entry)};
-			if (pos && *_trackPos >= *pos)
-				(*_trackPos)--;
-			else if (*_trackPos >= _entriesContainer->getCount())
-				_trackPos.reset();
-		}
-
-		_entriesContainer->remove(*entry);
-
-		updateInfo();
-	});
-
-	entry->bindNew<Wt::WPushButton>("more-btn", Wt::WString::tr("Lms.template.more-btn"), Wt::TextFormat::XHTML);
-	entry->bindNew<Wt::WPushButton>("play", Wt::WString::tr("Lms.Explore.play"))
-		->clicked().connect([=]
-		{
-			const std::optional<std::size_t> pos {_entriesContainer->getIndexOf(*entry)};
-			if (pos)
-				loadTrack(*pos, true);
-		});
-
-	auto isStarred {[=] { return Service<Scrobbling::IScrobblingService>::get()->isStarred(LmsApp->getUserId(), trackId); }};
-
-	Wt::WPushButton* starBtn {entry->bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star"))};
-	starBtn->clicked().connect([=]
-	{
-		auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
-
-		if (isStarred())
-		{
-			Service<Scrobbling::IScrobblingService>::get()->unstar(LmsApp->getUserId(), trackId);
-			starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
-		}
-		else
-		{
-			Service<Scrobbling::IScrobblingService>::get()->star(LmsApp->getUserId(), trackId);
-			starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
-		}
-	});
-
-	entry->bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
-		->setLink(Wt::WLink {std::make_unique<DownloadTrackResource>(trackId)});
-}
-
-void
-PlayQueue::enqueueRadioTracksIfNeeded()
-{
-	if (!isRadioModeSet())
-		return;
-
-	bool addTracks {};
-	{
-		auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-
-		const Database::TrackList::pointer queue {getQueue()};
-
-		// If out of range, stop playing
-		if (_trackPos >= queue->getCount() - 1)
-			addTracks = true;
-	}
-
-	if (addTracks)
-		enqueueRadioTracks();
-}
-
-void
-PlayQueue::enqueueRadioTracks()
-{
-	std::vector<Database::TrackId> trackIds = Service<Recommendation::IPlaylistGeneratorService>::get()->extendPlaylist(_queueId, 15);
-	enqueueTracks(trackIds);
-}
-
-std::optional<float>
-PlayQueue::getReplayGain(std::size_t pos, const Database::Track::pointer& track) const
-{
-	const auto& settings {LmsApp->getMediaPlayer().getSettings()};
-	if (!settings)
-		return std::nullopt;
-
-	std::optional<MediaPlayer::Gain> gain;
-
-	switch (settings->replayGain.mode)
-	{
-		case MediaPlayer::Settings::ReplayGain::Mode::None:
-			return std::nullopt;
-
-		case MediaPlayer::Settings::ReplayGain::Mode::Track:
-			gain = track->getTrackReplayGain();
-			break;
-
-		case MediaPlayer::Settings::ReplayGain::Mode::Release:
-			gain = track->getReleaseReplayGain();
-			if (!gain)
-				gain = track->getTrackReplayGain();
-			break;
-
-		case MediaPlayer::Settings::ReplayGain::Mode::Auto:
-		{
-			const Database::TrackList::pointer queue {getQueue()};
-			const Database::TrackListEntry::pointer prevEntry {pos > 0 ? queue->getEntry(pos - 1) : Database::TrackListEntry::pointer {}};
-			const Database::TrackListEntry::pointer nextEntry {queue->getEntry(pos + 1)};
-			const Database::Track::pointer prevTrack {prevEntry ? prevEntry->getTrack() : Database::Track::pointer {}};
-			const Database::Track::pointer nextTrack {nextEntry ? nextEntry->getTrack() : Database::Track::pointer {}};
-
-			if ((prevTrack && prevTrack->getRelease() && prevTrack->getRelease() == track->getRelease())
-				||
-				(nextTrack && nextTrack->getRelease() && nextTrack->getRelease() == track->getRelease()))
-			{
-				gain = track->getReleaseReplayGain();
-				if (!gain)
-					gain = track->getTrackReplayGain();
-			}
-			else
-			{
-				gain = track->getTrackReplayGain();
-			}
-			break;
-		}
-	}
-
-	if (gain)
-		return *gain + settings->replayGain.preAmpGain;
-
-	return settings->replayGain.preAmpGainIfNoInfo;
-}
-
-void
-PlayQueue::saveAsTrackList()
-{
-	auto modal {std::make_unique<Template>(Wt::WString::tr("Lms.PlayQueue.template.save-as-tracklist"))};
-	modal->addFunction("id", &Wt::WTemplate::Functions::id);
-	modal->addFunction("tr", &Wt::WTemplate::Functions::tr);
-	Wt::WWidget* modalPtr {modal.get()};
-
-	auto* cancelBtn {modal->bindNew<Wt::WPushButton>("cancel-btn", Wt::WString::tr("Lms.cancel"))};
-	cancelBtn->clicked().connect([=]
-	{
-		LmsApp->getModalManager().dispose(modalPtr);
-	});
-
-	Wt::WStackedWidget* contentStack {modal->bindNew<Wt::WStackedWidget>("contents")};
-
-	// Create/Replace selector
-	enum Index : int
-	{
-		CreateTrackList = 0,
-		ReplaceTrackList = 1,
-	};
-	{
-		modal->bindNew<Wt::WRadioButton>("replace-tracklist-btn")
-			->clicked().connect([=]
-			{
-				contentStack->setCurrentIndex(Index::ReplaceTrackList);
-			});
-
-		Wt::WRadioButton* createTrackListBtn {modal->bindNew<Wt::WRadioButton>("create-tracklist-btn")};
-		createTrackListBtn->setChecked();
-		createTrackListBtn->clicked().connect([=]
-		{
-			contentStack->setCurrentIndex(Index::CreateTrackList);
-		});
-	}
-
-
-	// Create TrackList
-	Wt::WTemplateFormView* createTrackList {contentStack->addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.PlayQueue.template.save-as-tracklist.create-tracklist"))};
-	auto createTrackListModel {std::make_shared<CreateTrackListModel>()};
-	createTrackList->setFormWidget(CreateTrackListModel::NameField, std::make_unique<Wt::WLineEdit>());
-	createTrackList->updateView(createTrackListModel.get());
-
-	// Replace TrackList
-	Wt::WTemplateFormView* replaceTrackList {contentStack->addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.PlayQueue.template.save-as-tracklist.replace-tracklist"))};
-	auto replaceTrackListModel {std::make_shared<ReplaceTrackListModel>()};
-	{
-		auto name {std::make_unique<Wt::WComboBox>()};
-		name->setModel(replaceTrackListModel->trackListModel);
-		replaceTrackList->setFormWidget(ReplaceTrackListModel::NameField, std::move(name));
-	}
-	replaceTrackList->updateView(replaceTrackListModel.get());
-
-	auto* saveBtn {modal->bindNew<Wt::WPushButton>("save-btn", Wt::WString::tr("Lms.save"))};
-	saveBtn->clicked().connect([=]
-	{
-		bool success {};
-		switch (contentStack->currentIndex())
-		{
-			case Index::CreateTrackList:
-				createTrackList->updateModel(createTrackListModel.get());
-				if (createTrackListModel->validate())
-				{
-					exportToNewTrackList(createTrackListModel->getName());
-					success = true;
-				}
-				createTrackList->updateView(createTrackListModel.get());
-				break;
-
-			case Index::ReplaceTrackList:
-				replaceTrackList->updateModel(replaceTrackListModel.get());
-				if (replaceTrackListModel->validate())
-				{
-					exportToTrackList(replaceTrackListModel->getTrackListId());
-					success = true;
-				}
-				replaceTrackList->updateView(replaceTrackListModel.get());
-				break;
-		}
-
-		if (success)
-			LmsApp->getModalManager().dispose(modalPtr);
-	});
-
-	LmsApp->getModalManager().show(std::move(modal));
-}
-
-void
-PlayQueue::exportToNewTrackList(const Wt::WString& name)
-{
-	using namespace Database;
-
-	Database::TrackListId trackListId;
-
-	{
-		Session& session {LmsApp->getDbSession()};
-		auto transaction {session.createUniqueTransaction()};
-		TrackList::pointer trackList {session.create<TrackList>(name.toUTF8(), TrackListType::Playlist, false, LmsApp->getUser())};
-		trackListId = trackList->getId();
-	}
-
-	exportToTrackList(trackListId);
-}
-
-void
-PlayQueue::exportToTrackList(Database::TrackListId trackListId)
-{
-	using namespace Database;
-
-	Session& session {LmsApp->getDbSession()};
-	auto transaction {session.createUniqueTransaction()};
-
-	TrackList::pointer trackList {TrackList::find(LmsApp->getDbSession(), trackListId)};
-	trackList.modify()->clear();
-
-	Track::FindParameters params;
-	params.setTrackList(_queueId);
-	params.setDistinct(false);
-	params.setSortMethod(TrackSortMethod::TrackList);
-
-	const auto tracks {Track::find(session, params)};
-	for (const TrackId trackId : tracks.results)
-		session.create<TrackListEntry>(Track::find(session, trackId), trackList);
-}
-
-
+    namespace
+    {
+        class CreateTrackListModel : public Wt::WFormModel
+        {
+        public:
+            static inline const Field NameField{ "name" };
+
+            CreateTrackListModel()
+            {
+                addField(NameField);
+                setValidator(NameField, createMandatoryValidator());
+            }
+
+            Wt::WString getName() const { return valueText(NameField); }
+        };
+
+        class ReplaceTrackListModel : public Wt::WFormModel
+        {
+        public:
+            static inline const Field NameField{ "name" };
+            using TrackListModel = ValueStringModel<Database::TrackListId>;
+
+            ReplaceTrackListModel()
+            {
+                addField(NameField);
+                setValidator(NameField, createMandatoryValidator());
+            }
+
+            Database::TrackListId getTrackListId() const
+            {
+                auto row{ trackListModel->getRowFromString(valueText(NameField)) };
+                return trackListModel->getValue(*row);
+            }
+
+            static
+                std::shared_ptr<TrackListModel>
+                createTrackListModel()
+            {
+                using namespace Database;
+
+                auto model{ std::make_shared<TrackListModel>() };
+
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+
+                TrackList::FindParameters params;
+                params.setType(TrackListType::Playlist);
+                params.setUser(LmsApp->getUserId());
+                params.setSortMethod(TrackListSortMethod::Name);
+
+                auto tracklists{ TrackList::find(LmsApp->getDbSession(), params) };
+                for (const TrackListId trackListId : tracklists.results)
+                {
+                    const TrackList::pointer trackList{ TrackList::find(LmsApp->getDbSession(), trackListId) };
+                    model->add(Wt::WString::fromUTF8(std::string{ trackList->getName() }), trackListId);
+                }
+
+                return model;
+            }
+
+            std::shared_ptr<TrackListModel> trackListModel{ createTrackListModel() };
+        };
+    }
+
+    PlayQueue::PlayQueue()
+        : Template{ Wt::WString::tr("Lms.PlayQueue.template") }
+        , _capacity{ Service<IConfig>::get()->getULong("playqueue-max-entry-count", 1000) }
+    {
+        initTrackLists();
+
+        addFunction("id", &Wt::WTemplate::Functions::id);
+        addFunction("tr", &Wt::WTemplate::Functions::tr);
+
+        Wt::WPushButton* clearBtn{ bindNew<Wt::WPushButton>("clear-btn", Wt::WString::tr("Lms.PlayQueue.template.clear-btn"), Wt::TextFormat::XHTML) };
+        clearBtn->clicked().connect([=]
+            {
+                clearTracks();
+            });
+
+        Wt::WPushButton* saveBtn{ bindNew<Wt::WPushButton>("save-btn", Wt::WString::tr("Lms.PlayQueue.template.save-btn"), Wt::TextFormat::XHTML) };
+        saveBtn->clicked().connect([=]
+            {
+                saveAsTrackList();
+            });
+
+        _entriesContainer = bindNew<InfiniteScrollingContainer>("entries", Wt::WString::tr("Lms.PlayQueue.template.entry-container"));
+        _entriesContainer->onRequestElements.connect([this]
+            {
+                addSome();
+                updateCurrentTrack(true);
+            });
+
+        Wt::WPushButton* shuffleBtn{ bindNew<Wt::WPushButton>("shuffle-btn", Wt::WString::tr("Lms.PlayQueue.template.shuffle-btn"), Wt::TextFormat::XHTML) };
+        shuffleBtn->clicked().connect([=]
+            {
+                {
+                    auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
+
+                    Database::TrackList::pointer queue{ getQueue() };
+                    auto entries{ queue->getEntries() };
+                    Random::shuffleContainer(entries);
+
+                    queue.modify()->clear();
+                    for (const Database::TrackListEntry::pointer& entry : entries)
+                        LmsApp->getDbSession().create<Database::TrackListEntry>(entry->getTrack(), queue);
+                }
+                _entriesContainer->reset();
+                addSome();
+            });
+
+        _repeatBtn = bindNew<Wt::WCheckBox>("repeat-btn");
+        _repeatBtn->clicked().connect([=]
+            {
+                auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
+
+                if (!LmsApp->getUser()->isDemo())
+                    LmsApp->getUser().modify()->setRepeatAll(isRepeatAllSet());
+            });
+        {
+            auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+            if (LmsApp->getUser()->isRepeatAllSet())
+                _repeatBtn->setCheckState(Wt::CheckState::Checked);
+        }
+
+        _radioBtn = bindNew<Wt::WCheckBox>("radio-btn");
+        _radioBtn->clicked().connect([=]
+            {
+                {
+                    auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
+
+                    if (!LmsApp->getUser()->isDemo())
+                        LmsApp->getUser().modify()->setRadio(isRadioModeSet());
+                }
+                if (isRadioModeSet())
+                    enqueueRadioTracksIfNeeded();
+            });
+
+        bool isRadioModeSet{};
+        {
+            auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+            isRadioModeSet = LmsApp->getUser()->isRadioSet();
+        }
+        if (isRadioModeSet)
+        {
+            _radioBtn->setCheckState(Wt::CheckState::Checked);
+            enqueueRadioTracksIfNeeded();
+        }
+
+        _nbTracks = bindNew<Wt::WText>("track-count");
+        _duration = bindNew<Wt::WText>("duration");
+
+        LmsApp->getMediaPlayer().settingsLoaded.connect([=]
+            {
+                if (_mediaPlayerSettingsLoaded)
+                    return;
+
+                _mediaPlayerSettingsLoaded = true;
+
+                std::size_t trackPos{};
+
+                {
+                    auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                    trackPos = LmsApp->getUser()->getCurPlayingTrackPos();
+                }
+
+                loadTrack(trackPos, false);
+            });
+
+        LmsApp->preQuit().connect([=]
+            {
+                auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
+
+                if (LmsApp->getUser()->isDemo())
+                {
+                    LMS_LOG(UI, DEBUG) << "Removing queue (tracklist id " << _queueId.toString() << ")";
+                    if (Database::TrackList::pointer queue{ getQueue() })
+                        queue.remove();
+                }
+            });
+
+        updateInfo();
+    }
+
+    bool PlayQueue::isRepeatAllSet() const
+    {
+        return _repeatBtn->checkState() == Wt::CheckState::Checked;
+    }
+
+    bool PlayQueue::isRadioModeSet() const
+    {
+        return _radioBtn->checkState() == Wt::CheckState::Checked;
+    }
+
+    Database::TrackList::pointer PlayQueue::getQueue() const
+    {
+        return Database::TrackList::find(LmsApp->getDbSession(), _queueId);
+    }
+
+    bool PlayQueue::isFull() const
+    {
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+        return getQueue()->getCount() == getCapacity();
+    }
+
+    void PlayQueue::clearTracks()
+    {
+        {
+            auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
+            getQueue().modify()->clear();
+        }
+
+        _entriesContainer->reset();
+        _trackPos.reset();
+        updateInfo();
+    }
+
+    void PlayQueue::stop()
+    {
+        updateCurrentTrack(false);
+        _trackPos.reset();
+        _isTrackSelected = false;
+        trackUnselected.emit();
+    }
+
+    void PlayQueue::loadTrack(std::size_t pos, bool play)
+    {
+        updateCurrentTrack(false);
+
+        Database::TrackId trackId{};
+        std::optional<float> replayGain{};
+        {
+            auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+
+            const Database::TrackList::pointer queue{ getQueue() };
+
+            // If out of range, stop playing
+            if (pos >= queue->getCount())
+            {
+                if (!isRepeatAllSet() || queue->getCount() == 0)
+                {
+                    stop();
+                    return;
+                }
+
+                pos = 0;
+            }
+
+            _trackPos = pos;
+            const Database::Track::pointer track{ queue->getEntry(*_trackPos)->getTrack() };
+
+            trackId = track->getId();
+
+            replayGain = getReplayGain(pos, track);
+
+            if (!LmsApp->getUser()->isDemo())
+                LmsApp->getUser().modify()->setCurPlayingTrackPos(pos);
+        }
+
+        enqueueRadioTracksIfNeeded();
+        updateCurrentTrack(true);
+        _isTrackSelected = true;
+        trackSelected.emit(trackId, play, replayGain ? *replayGain : 0);
+    }
+
+    void PlayQueue::playPrevious()
+    {
+        if (!_trackPos)
+            return;
+
+        if (*_trackPos == 0)
+            stop();
+        else
+            loadTrack(*_trackPos - 1, true);
+    }
+
+    void PlayQueue::playNext()
+    {
+        if (!_trackPos)
+        {
+            loadTrack(0, true);
+            return;
+        }
+
+        loadTrack(*_trackPos + 1, true);
+    }
+
+    void PlayQueue::onPlaybackEnded()
+    {
+        playNext();
+    }
+
+    std::size_t PlayQueue::getCount()
+    {
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+        return getQueue()->getCount();
+    }
+
+    void PlayQueue::initTrackLists()
+    {
+        auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
+
+        Database::TrackList::pointer queue;
+        Database::TrackList::pointer radioStartingTracks;
+
+        if (!LmsApp->getUser()->isDemo())
+        {
+            static const std::string queueName{ "__queued_tracks__" };
+            queue = Database::TrackList::find(LmsApp->getDbSession(), queueName, Database::TrackListType::Internal, LmsApp->getUserId());
+            if (!queue)
+                queue = LmsApp->getDbSession().create<Database::TrackList>(queueName, Database::TrackListType::Internal, false, LmsApp->getUser());
+        }
+        else
+        {
+            static const std::string queueName{ "__temp_queue__" };
+            queue = LmsApp->getDbSession().create<Database::TrackList>(queueName, Database::TrackListType::Internal, false, LmsApp->getUser());
+        }
+
+        _queueId = queue->getId();
+    }
+
+    void PlayQueue::updateInfo()
+    {
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+
+        const Database::TrackList::pointer queue{ getQueue() };
+        const std::size_t trackCount{ queue->getCount() };
+        _nbTracks->setText(Wt::WString::trn("Lms.track-count", trackCount).arg(trackCount));
+        _duration->setText(Utils::durationToString(queue->getDuration()));
+        trackCountChanged.emit(trackCount);
+    }
+
+    void PlayQueue::updateCurrentTrack(bool selected)
+    {
+        if (!_trackPos || *_trackPos >= static_cast<std::size_t>(_entriesContainer->getCount()))
+            return;
+
+        Template* entry{ static_cast<Template*>(_entriesContainer->getWidget(*_trackPos)) };
+        if (!entry)
+            return;
+
+        entry->toggleStyleClass("Lms-entry-playing", selected);
+    }
+
+    void PlayQueue::enqueueTracks(const std::vector<Database::TrackId>& trackIds)
+    {
+        {
+            auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
+
+            Database::TrackList::pointer queue{ getQueue() };
+            const std::size_t queueSize{ queue->getCount() };
+
+            std::size_t nbTracksToEnqueue{ queueSize + trackIds.size() > getCapacity() ? getCapacity() - queueSize : trackIds.size() };
+            for (const Database::TrackId trackId : trackIds)
+            {
+                if (nbTracksToEnqueue == 0)
+                    break;
+
+                Database::Track::pointer track{ Database::Track::find(LmsApp->getDbSession(), trackId) };
+                if (!track)
+                    continue;
+
+                LmsApp->getDbSession().create<Database::TrackListEntry>(track, queue);
+                nbTracksToEnqueue--;
+            }
+        }
+
+        updateInfo();
+        addSome();
+        _entriesContainer->setHasMore();
+    }
+
+    std::vector<Database::TrackId> PlayQueue::getAndClearNextTracks()
+    {
+        std::vector<Database::TrackId> tracks;
+
+        auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
+
+        Database::TrackList::pointer queue{ getQueue() };
+        std::vector<Database::TrackListEntry::pointer> entries{ queue->getEntries(Database::Range {_trackPos ? *_trackPos + 1 : 0, getCapacity()}) };
+        tracks.reserve(entries.size());
+        for (Database::TrackListEntry::pointer entry : entries)
+        {
+            tracks.push_back(entry->getTrack()->getId());
+            entry.remove();
+        }
+
+        if (_trackPos)
+        {
+            // entries may have been cleared
+            if (*_trackPos + 1 < _entriesContainer->getCount())
+                _entriesContainer->remove(*_trackPos + 1, _entriesContainer->getCount() - 1);
+        }
+        else
+        {
+            _entriesContainer->reset();
+        }
+
+        return tracks;
+    }
+
+    void PlayQueue::play(const std::vector<Database::TrackId>& trackIds)
+    {
+        playAtIndex(trackIds, 0);
+    }
+
+    void PlayQueue::playNext(const std::vector<Database::TrackId>& trackIds)
+    {
+        std::vector<Database::TrackId> nextTracks{ getAndClearNextTracks() };
+        nextTracks.insert(std::cbegin(nextTracks), std::cbegin(trackIds), std::cend(trackIds));
+        playOrAddLast(nextTracks);
+    }
+
+    void PlayQueue::playShuffled(const std::vector<Database::TrackId>& trackIds)
+    {
+        clearTracks();
+        std::vector<Database::TrackId> shuffledTrackIds{ trackIds };
+        Random::shuffleContainer(shuffledTrackIds);
+        enqueueTracks(shuffledTrackIds);
+        loadTrack(0, true);
+    }
+
+    void PlayQueue::playOrAddLast(const std::vector<Database::TrackId>& trackIds)
+    {
+        enqueueTracks(trackIds);
+        if (!_isTrackSelected)
+            loadTrack(0, true);
+    }
+
+    void PlayQueue::playAtIndex(const std::vector<Database::TrackId>& trackIds, std::size_t index)
+    {
+        clearTracks();
+        enqueueTracks(trackIds);
+        loadTrack(index, true);
+    }
+
+    void PlayQueue::addSome()
+    {
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+
+        const Database::TrackList::pointer queue{ getQueue() };
+        const auto tracklistEntries{ queue->getEntries(Database::Range {_entriesContainer->getCount(), _batchSize}) };
+        for (const Database::TrackListEntry::pointer& tracklistEntry : tracklistEntries)
+            addEntry(tracklistEntry);
+    }
+
+    void PlayQueue::addEntry(const Database::TrackListEntry::pointer& tracklistEntry)
+    {
+        const Database::TrackListEntryId tracklistEntryId{ tracklistEntry->getId() };
+        const auto track{ tracklistEntry->getTrack() };
+        const Database::TrackId trackId{ track->getId() };
+
+        Template* entry{ _entriesContainer->addNew<Template>(Wt::WString::tr("Lms.PlayQueue.template.entry")) };
+        entry->addFunction("id", &Wt::WTemplate::Functions::id);
+
+        entry->bindString("name", Wt::WString::fromUTF8(track->getName()), Wt::TextFormat::Plain);
+
+        const auto artists{ track->getArtistIds({Database::TrackArtistLinkType::Artist}) };
+        if (!artists.empty())
+        {
+            entry->setCondition("if-has-artists", true);
+            entry->bindWidget("artists", Utils::createArtistAnchorList(artists));
+            entry->bindWidget("artists-md", Utils::createArtistAnchorList(artists));
+        }
+
+        const auto release{ track->getRelease() };
+        if (release)
+        {
+            entry->setCondition("if-has-release", true);
+            entry->bindWidget("release", Utils::createReleaseAnchor(release));
+            {
+                Wt::WAnchor* anchor{ entry->bindWidget("cover", Utils::createReleaseAnchor(release, false)) };
+                auto cover{ Utils::createCover(release->getId(), CoverResource::Size::Small) };
+                cover->addStyleClass("Lms-cover-track Lms-cover-anchor"); // HACK
+                anchor->setImage(std::move(cover));
+            }
+        }
+        else
+        {
+            auto cover{ entry->bindWidget<Wt::WImage>("cover", Utils::createCover(track->getId(), CoverResource::Size::Small)) };
+            cover->addStyleClass("Lms-cover-track");
+        }
+
+        entry->bindString("duration", Utils::durationToString(track->getDuration()), Wt::TextFormat::Plain);
+
+        Wt::WPushButton* playBtn{ entry->bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.template.play-btn"), Wt::TextFormat::XHTML) };
+        playBtn->clicked().connect([=]
+            {
+                const std::optional<std::size_t> pos{ _entriesContainer->getIndexOf(*entry) };
+                if (pos)
+                    loadTrack(*pos, true);
+            });
+
+        Wt::WPushButton* delBtn{ entry->bindNew<Wt::WPushButton>("del-btn", Wt::WString::tr("Lms.template.delete-btn"), Wt::TextFormat::XHTML) };
+        delBtn->setToolTip(Wt::WString::tr("Lms.delete"));
+        delBtn->clicked().connect([=]
+            {
+                // Remove the entry n both the widget tree and the playqueue
+                {
+                    auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
+
+                    Database::TrackListEntry::pointer entryToRemove{ Database::TrackListEntry::getById(LmsApp->getDbSession(), tracklistEntryId) };
+                    entryToRemove.remove();
+                }
+
+                if (_trackPos)
+                {
+                    const std::optional<std::size_t> pos{ _entriesContainer->getIndexOf(*entry) };
+                    if (pos && *_trackPos >= *pos)
+                        (*_trackPos)--;
+                    else if (*_trackPos >= _entriesContainer->getCount())
+                        _trackPos.reset();
+                }
+
+                _entriesContainer->remove(*entry);
+
+                updateInfo();
+            });
+
+        entry->bindNew<Wt::WPushButton>("more-btn", Wt::WString::tr("Lms.template.more-btn"), Wt::TextFormat::XHTML);
+        entry->bindNew<Wt::WPushButton>("play", Wt::WString::tr("Lms.Explore.play"))
+            ->clicked().connect([=]
+                {
+                    const std::optional<std::size_t> pos{ _entriesContainer->getIndexOf(*entry) };
+                    if (pos)
+                        loadTrack(*pos, true);
+                });
+
+        auto isStarred{ [=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), trackId); } };
+
+        Wt::WPushButton* starBtn{ entry->bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star")) };
+        starBtn->clicked().connect([=]
+            {
+                auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
+
+                if (isStarred())
+                {
+                    Service<Feedback::IFeedbackService>::get()->unstar(LmsApp->getUserId(), trackId);
+                    starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
+                }
+                else
+                {
+                    Service<Feedback::IFeedbackService>::get()->star(LmsApp->getUserId(), trackId);
+                    starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
+                }
+            });
+
+        entry->bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
+            ->setLink(Wt::WLink{ std::make_unique<DownloadTrackResource>(trackId) });
+    }
+
+    void PlayQueue::enqueueRadioTracksIfNeeded()
+    {
+        if (!isRadioModeSet())
+            return;
+
+        bool addTracks{};
+        {
+            auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+
+            const Database::TrackList::pointer queue{ getQueue() };
+
+            // If out of range, stop playing
+            if (_trackPos >= queue->getCount() - 1)
+                addTracks = true;
+        }
+
+        if (addTracks)
+            enqueueRadioTracks();
+    }
+
+    void PlayQueue::enqueueRadioTracks()
+    {
+        std::vector<Database::TrackId> trackIds = Service<Recommendation::IPlaylistGeneratorService>::get()->extendPlaylist(_queueId, 15);
+        enqueueTracks(trackIds);
+    }
+
+    std::optional<float> PlayQueue::getReplayGain(std::size_t pos, const Database::Track::pointer& track) const
+    {
+        const auto& settings{ LmsApp->getMediaPlayer().getSettings() };
+        if (!settings)
+            return std::nullopt;
+
+        std::optional<MediaPlayer::Gain> gain;
+
+        switch (settings->replayGain.mode)
+        {
+        case MediaPlayer::Settings::ReplayGain::Mode::None:
+            return std::nullopt;
+
+        case MediaPlayer::Settings::ReplayGain::Mode::Track:
+            gain = track->getTrackReplayGain();
+            break;
+
+        case MediaPlayer::Settings::ReplayGain::Mode::Release:
+            gain = track->getReleaseReplayGain();
+            if (!gain)
+                gain = track->getTrackReplayGain();
+            break;
+
+        case MediaPlayer::Settings::ReplayGain::Mode::Auto:
+        {
+            const Database::TrackList::pointer queue{ getQueue() };
+            const Database::TrackListEntry::pointer prevEntry{ pos > 0 ? queue->getEntry(pos - 1) : Database::TrackListEntry::pointer {} };
+            const Database::TrackListEntry::pointer nextEntry{ queue->getEntry(pos + 1) };
+            const Database::Track::pointer prevTrack{ prevEntry ? prevEntry->getTrack() : Database::Track::pointer {} };
+            const Database::Track::pointer nextTrack{ nextEntry ? nextEntry->getTrack() : Database::Track::pointer {} };
+
+            if ((prevTrack && prevTrack->getRelease() && prevTrack->getRelease() == track->getRelease())
+                ||
+                (nextTrack && nextTrack->getRelease() && nextTrack->getRelease() == track->getRelease()))
+            {
+                gain = track->getReleaseReplayGain();
+                if (!gain)
+                    gain = track->getTrackReplayGain();
+            }
+            else
+            {
+                gain = track->getTrackReplayGain();
+            }
+            break;
+        }
+        }
+
+        if (gain)
+            return *gain + settings->replayGain.preAmpGain;
+
+        return settings->replayGain.preAmpGainIfNoInfo;
+    }
+
+    void PlayQueue::saveAsTrackList()
+    {
+        auto modal{ std::make_unique<Template>(Wt::WString::tr("Lms.PlayQueue.template.save-as-tracklist")) };
+        modal->addFunction("id", &Wt::WTemplate::Functions::id);
+        modal->addFunction("tr", &Wt::WTemplate::Functions::tr);
+        Wt::WWidget* modalPtr{ modal.get() };
+
+        auto* cancelBtn{ modal->bindNew<Wt::WPushButton>("cancel-btn", Wt::WString::tr("Lms.cancel")) };
+        cancelBtn->clicked().connect([=]
+            {
+                LmsApp->getModalManager().dispose(modalPtr);
+            });
+
+        Wt::WStackedWidget* contentStack{ modal->bindNew<Wt::WStackedWidget>("contents") };
+
+        // Create/Replace selector
+        enum Index : int
+        {
+            CreateTrackList = 0,
+            ReplaceTrackList = 1,
+        };
+        {
+            modal->bindNew<Wt::WRadioButton>("replace-tracklist-btn")
+                ->clicked().connect([=]
+                    {
+                        contentStack->setCurrentIndex(Index::ReplaceTrackList);
+                    });
+
+            Wt::WRadioButton* createTrackListBtn{ modal->bindNew<Wt::WRadioButton>("create-tracklist-btn") };
+            createTrackListBtn->setChecked();
+            createTrackListBtn->clicked().connect([=]
+                {
+                    contentStack->setCurrentIndex(Index::CreateTrackList);
+                });
+        }
+
+
+        // Create TrackList
+        Wt::WTemplateFormView* createTrackList{ contentStack->addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.PlayQueue.template.save-as-tracklist.create-tracklist")) };
+        auto createTrackListModel{ std::make_shared<CreateTrackListModel>() };
+        createTrackList->setFormWidget(CreateTrackListModel::NameField, std::make_unique<Wt::WLineEdit>());
+        createTrackList->updateView(createTrackListModel.get());
+
+        // Replace TrackList
+        Wt::WTemplateFormView* replaceTrackList{ contentStack->addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.PlayQueue.template.save-as-tracklist.replace-tracklist")) };
+        auto replaceTrackListModel{ std::make_shared<ReplaceTrackListModel>() };
+        {
+            auto name{ std::make_unique<Wt::WComboBox>() };
+            name->setModel(replaceTrackListModel->trackListModel);
+            replaceTrackList->setFormWidget(ReplaceTrackListModel::NameField, std::move(name));
+        }
+        replaceTrackList->updateView(replaceTrackListModel.get());
+
+        auto* saveBtn{ modal->bindNew<Wt::WPushButton>("save-btn", Wt::WString::tr("Lms.save")) };
+        saveBtn->clicked().connect([=]
+            {
+                bool success{};
+                switch (contentStack->currentIndex())
+                {
+                case Index::CreateTrackList:
+                    createTrackList->updateModel(createTrackListModel.get());
+                    if (createTrackListModel->validate())
+                    {
+                        exportToNewTrackList(createTrackListModel->getName());
+                        success = true;
+                    }
+                    createTrackList->updateView(createTrackListModel.get());
+                    break;
+
+                case Index::ReplaceTrackList:
+                    replaceTrackList->updateModel(replaceTrackListModel.get());
+                    if (replaceTrackListModel->validate())
+                    {
+                        exportToTrackList(replaceTrackListModel->getTrackListId());
+                        success = true;
+                    }
+                    replaceTrackList->updateView(replaceTrackListModel.get());
+                    break;
+                }
+
+                if (success)
+                    LmsApp->getModalManager().dispose(modalPtr);
+            });
+
+        LmsApp->getModalManager().show(std::move(modal));
+    }
+
+    void PlayQueue::exportToNewTrackList(const Wt::WString& name)
+    {
+        using namespace Database;
+
+        Database::TrackListId trackListId;
+
+        {
+            Session& session{ LmsApp->getDbSession() };
+            auto transaction{ session.createUniqueTransaction() };
+            TrackList::pointer trackList{ session.create<TrackList>(name.toUTF8(), TrackListType::Playlist, false, LmsApp->getUser()) };
+            trackListId = trackList->getId();
+        }
+
+        exportToTrackList(trackListId);
+    }
+
+    void PlayQueue::exportToTrackList(Database::TrackListId trackListId)
+    {
+        using namespace Database;
+
+        Session& session{ LmsApp->getDbSession() };
+        auto transaction{ session.createUniqueTransaction() };
+
+        TrackList::pointer trackList{ TrackList::find(LmsApp->getDbSession(), trackListId) };
+        trackList.modify()->clear();
+
+        Track::FindParameters params;
+        params.setTrackList(_queueId);
+        params.setDistinct(false);
+        params.setSortMethod(TrackSortMethod::TrackList);
+
+        const auto tracks{ Track::find(session, params) };
+        for (const Track::pointer& track : tracks.results)
+            session.create<TrackListEntry>(track, trackList);
+    }
 } // namespace UserInterface
-
diff --git a/src/lms/ui/SettingsView.cpp b/src/lms/ui/SettingsView.cpp
index cda71da2..03224b66 100644
--- a/src/lms/ui/SettingsView.cpp
+++ b/src/lms/ui/SettingsView.cpp
@@ -46,506 +46,540 @@
 
 namespace UserInterface {
 
-using namespace Database;
-
-class SettingsModel : public Wt::WFormModel
-{
-	public:
-		// Associate each field with a unique string literal.
-		static inline const Field TranscodeModeField {"transcode-mode"};
-		static inline const Field TranscodeFormatField {"transcode-format"};
-		static inline const Field TranscodeBitrateField {"transcode-bitrate"};
-		static inline const Field ReplayGainModeField {"replaygain-mode"};
-		static inline const Field ReplayGainPreAmpGainField {"replaygain-preamp"};
-		static inline const Field ReplayGainPreAmpGainIfNoInfoField {"replaygain-preamp-no-rg-info"};
-		static inline const Field SubsonicArtistListModeField {"subsonic-artist-list-mode"};
-		static inline const Field SubsonicTranscodeEnableField {"subsonic-transcode-enable"};
-		static inline const Field SubsonicTranscodeFormatField {"subsonic-transcode-format"};
-		static inline const Field SubsonicTranscodeBitrateField {"subsonic-transcode-bitrate"};
-		static inline const Field ScrobblerField {"scrobbler"};
-		static inline const Field ListenBrainzTokenField {"listenbrainz-token"};
-		static inline const Field PasswordOldField {"password-old"};
-		static inline const Field PasswordField {"password"};
-		static inline const Field PasswordConfirmField {"password-confirm"};
-
-		using TranscodeModeModel = ValueStringModel<MediaPlayer::Settings::Transcode::Mode>;
-		using ReplayGainModeModel = ValueStringModel<MediaPlayer::Settings::ReplayGain::Mode>;
-		using ScrobblerModel = ValueStringModel<Scrobbler>;
-
-		SettingsModel(::Auth::IPasswordService* authPasswordService, bool withOldPassword)
-			: _authPasswordService {authPasswordService}
-			, _withOldPassword {withOldPassword}
-		{
-			initializeModels();
-
-			addField(TranscodeModeField);
-			addField(TranscodeBitrateField);
-			addField(TranscodeFormatField);
-			addField(ReplayGainModeField);
-			addField(ReplayGainPreAmpGainField);
-			addField(ReplayGainPreAmpGainIfNoInfoField);
-			addField(SubsonicTranscodeEnableField);
-			addField(SubsonicTranscodeBitrateField);
-			addField(SubsonicTranscodeFormatField);
-			addField(ScrobblerField);
-			addField(ListenBrainzTokenField);
-			setValidator(ListenBrainzTokenField, createUUIDValidator());
-
-			if (_authPasswordService)
-			{
-				if (_withOldPassword)
-				{
-					addField(PasswordOldField);
-					setValidator(PasswordOldField, createPasswordCheckValidator());
-				}
-
-				addField(PasswordField);
-				setValidator(PasswordField, createPasswordStrengthValidator([] { return ::Auth::PasswordValidationContext {LmsApp->getUserLoginName(), LmsApp->getUserType()}; }));
-				addField(PasswordConfirmField);
-			}
-
-			setValidator(TranscodeModeField, createMandatoryValidator());
-			setValidator(TranscodeBitrateField, createMandatoryValidator());
-			setValidator(TranscodeFormatField, createMandatoryValidator());
-			setValidator(ReplayGainModeField, createMandatoryValidator());
-			auto createPreAmpValidator {[]
-			{
-				return createDoubleValidator(MediaPlayer::Settings::ReplayGain::minPreAmpGain, MediaPlayer::Settings::ReplayGain::maxPreAmpGain);
-			}};
-
-			setValidator(ReplayGainPreAmpGainField, createPreAmpValidator());
-			setValidator(ReplayGainPreAmpGainIfNoInfoField, createPreAmpValidator());
-			setValidator(SubsonicTranscodeBitrateField, createMandatoryValidator());
-			setValidator(SubsonicTranscodeFormatField, createMandatoryValidator());
-
-			loadData();
-		}
-
-		std::shared_ptr<TranscodeModeModel>		getTranscodeModeModel() { return _transcodeModeModel; }
-		std::shared_ptr<Wt::WAbstractItemModel>	getTranscodeBitrateModel() { return _transcodeBitrateModel; }
-		std::shared_ptr<Wt::WAbstractItemModel>	getTranscodeFormatModel() { return _transcodeFormatModel; }
-		std::shared_ptr<ReplayGainModeModel>	getReplayGainModeModel() { return _replayGainModeModel; }
-		std::shared_ptr<Wt::WAbstractItemModel>	getSubsonicArtistListModeModel() { return _subsonicArtistListModeModel; }
-		std::shared_ptr<ScrobblerModel>			getScrobblerModel() { return _scrobblerModel; }
-
-		void saveData()
-		{
-			auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
-
-			User::pointer user {LmsApp->getUser()};
-
-			{
-				MediaPlayer::Settings settings;
-
-				auto transcodeModeRow {_transcodeModeModel->getRowFromString(valueText(TranscodeModeField))};
-				if (transcodeModeRow)
-					settings.transcode.mode = _transcodeModeModel->getValue(*transcodeModeRow);
-
-				auto transcodeFormatRow {_transcodeFormatModel->getRowFromString(valueText(TranscodeFormatField))};
-				if (transcodeFormatRow)
-					settings.transcode.format = _transcodeFormatModel->getValue(*transcodeFormatRow);
-
-				auto transcodeBitrateRow {_transcodeBitrateModel->getRowFromString(valueText(TranscodeBitrateField))};
-				if (transcodeBitrateRow)
-					settings.transcode.bitrate = _transcodeBitrateModel->getValue(*transcodeBitrateRow);
-
-				auto replayGainModeRow {_replayGainModeModel->getRowFromString(valueText(ReplayGainModeField))};
-				if (replayGainModeRow)
-					settings.replayGain.mode = _replayGainModeModel->getValue(*replayGainModeRow);
-
-				settings.replayGain.preAmpGain = Wt::asNumber(value(ReplayGainPreAmpGainField));
-				settings.replayGain.preAmpGainIfNoInfo = Wt::asNumber(value(ReplayGainPreAmpGainIfNoInfoField));
-
-				LmsApp->getMediaPlayer().setSettings(settings);
-			}
-
-			{
-				auto subsonicTranscodeBitrateRow {_transcodeBitrateModel->getRowFromString(valueText(SubsonicTranscodeBitrateField))};
-				if (subsonicTranscodeBitrateRow)
-					user.modify()->setSubsonicDefaultTranscodeBitrate(_transcodeBitrateModel->getValue(*subsonicTranscodeBitrateRow));
-
-				auto subsonicTranscodeFormatRow {_transcodeFormatModel->getRowFromString(valueText(SubsonicTranscodeFormatField))};
-				if (subsonicTranscodeFormatRow)
-					user.modify()->setSubsonicDefaultTranscodeFormat(_transcodeFormatModel->getValue(*subsonicTranscodeFormatRow));
-
-				auto subsonicArtistListModeRow {_subsonicArtistListModeModel->getRowFromString(valueText(SubsonicArtistListModeField))};
-				if (subsonicArtistListModeRow)
-					user.modify()->setSubsonicArtistListMode(_subsonicArtistListModeModel->getValue(*subsonicArtistListModeRow));
-
-			}
-
-			{
-				if (auto scrobblerRow {_scrobblerModel->getRowFromString(valueText(ScrobblerField))})
-					user.modify()->setScrobbler(_scrobblerModel->getValue(*scrobblerRow));
-
-				user.modify()->setListenBrainzToken(UUID::fromString(Wt::asString(value(ListenBrainzTokenField)).toUTF8()));
-			}
-
-			if (_authPasswordService && !valueText(PasswordField).empty())
-			{
-				_authPasswordService->setPassword(user->getId(), valueText(PasswordField).toUTF8());
-			}
-		}
-
-		void loadData()
-		{
-			auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-
-			User::pointer user {LmsApp->getUser()};
-
-			{
-				const auto settings {*LmsApp->getMediaPlayer().getSettings()};
-
-				auto transcodeModeRow {_transcodeModeModel->getRowFromValue(settings.transcode.mode)};
-				if (transcodeModeRow)
-					setValue(TranscodeModeField, _transcodeModeModel->getString(*transcodeModeRow));
-
-				auto transcodeFormatRow {_transcodeFormatModel->getRowFromValue(settings.transcode.format)};
-				if (transcodeFormatRow)
-					setValue(TranscodeFormatField, _transcodeFormatModel->getString(*transcodeFormatRow));
-
-				auto transcodeBitrateRow {_transcodeBitrateModel->getRowFromValue(settings.transcode.bitrate)};
-				if (transcodeBitrateRow)
-					setValue(TranscodeBitrateField, _transcodeBitrateModel->getString(*transcodeBitrateRow));
-
-				{
-					const bool usesTranscode {settings.transcode.mode != MediaPlayer::Settings::Transcode::Mode::Never};
-					setReadOnly(SettingsModel::TranscodeFormatField, !usesTranscode);
-					setReadOnly(SettingsModel::TranscodeBitrateField, !usesTranscode);
-				}
-
-				auto replayGainModeRow {_replayGainModeModel->getRowFromValue(settings.replayGain.mode)};
-				if (replayGainModeRow)
-					setValue(ReplayGainModeField, _replayGainModeModel->getString(*replayGainModeRow));
-
-				setValue(ReplayGainPreAmpGainField, settings.replayGain.preAmpGain);
-				setValue(ReplayGainPreAmpGainIfNoInfoField, settings.replayGain.preAmpGainIfNoInfo);
-			}
-
-			{
-				auto subsonicTranscodeBitrateRow {_transcodeBitrateModel->getRowFromValue(user->getSubsonicDefaultTranscodeBitrate())};
-				if (subsonicTranscodeBitrateRow)
-					setValue(SubsonicTranscodeBitrateField, _transcodeBitrateModel->getString(*subsonicTranscodeBitrateRow));
-
-				auto subsonicTranscodeFormatRow {_transcodeFormatModel->getRowFromValue(user->getSubsonicDefaultTranscodeFormat())};
-				if (subsonicTranscodeFormatRow)
-					setValue(SubsonicTranscodeFormatField, _transcodeFormatModel->getString(*subsonicTranscodeFormatRow));
-
-				auto subsonicArtistListModeRow {_subsonicArtistListModeModel->getRowFromValue(user->getSubsonicArtistListMode())};
-				if (subsonicArtistListModeRow)
-					setValue(SubsonicArtistListModeField, _subsonicArtistListModeModel->getString(*subsonicArtistListModeRow));
-			}
-
-			{
-				if (auto scrobblerRow {_scrobblerModel->getRowFromValue(user->getScrobbler())})
-					setValue(ScrobblerField, _scrobblerModel->getString(*scrobblerRow));
-
-				if (auto listenBrainzToken {user->getListenBrainzToken()})
-				{
-					LMS_LOG(UI, DEBUG) << "Read listenBrainzToken! value = " << listenBrainzToken->getAsString();
-					setValue(ListenBrainzTokenField, Wt::WString::fromUTF8( std::string {listenBrainzToken->getAsString()}));
-				}
-
-				{
-					const bool usesListenBrainz {user->getScrobbler() == Scrobbler::ListenBrainz};
-					setReadOnly(SettingsModel::ListenBrainzTokenField, !usesListenBrainz);
-					validator(SettingsModel::ListenBrainzTokenField)->setMandatory(usesListenBrainz);
-				}
-			}
-			if (_authPasswordService)
-			{
-				if (_withOldPassword)
-					setValue(PasswordOldField, "");
-
-				setValue(PasswordField, "");
-				setValue(PasswordConfirmField, "");
-			}
-		}
-
-	private:
-		bool validateField(Field field)
-		{
-			Wt::WString error;
-
-			if (field == PasswordOldField)
-			{
-				if (valueText(PasswordOldField).empty() && !valueText(PasswordField).empty())
-					error = Wt::WString::tr("Lms.Settings.password-must-fill-old-password");
-				else
-					return Wt::WFormModel::validateField(field);
-			}
-			else if (field == PasswordField)
-			{
-				if (!valueText(PasswordOldField).empty() && valueText(PasswordField).empty())
-					error = Wt::WString::tr("Wt.WValidator.Invalid");
-				else
-					return Wt::WFormModel::validateField(field);
-			}
-			else if (field == PasswordConfirmField)
-			{
-				if (validation(PasswordField).state() == Wt::ValidationState::Valid)
-				{
-					if (valueText(PasswordField) != valueText(PasswordConfirmField))
-						error = Wt::WString::tr("Lms.passwords-dont-match");
-				}
-			}
-			else
-			{
-				return Wt::WFormModel::validateField(field);
-			}
-
-			setValidation(field, Wt::WValidator::Result( error.empty() ? Wt::ValidationState::Valid : Wt::ValidationState::Invalid, error));
-
-			return (validation(field).state() == Wt::ValidationState::Valid);
-		}
-
-	private:
-
-		void initializeModels()
-		{
-			_transcodeModeModel = std::make_shared<TranscodeModeModel>();
-			_transcodeModeModel->add(Wt::WString::tr("Lms.Settings.transcode-mode.always"), MediaPlayer::Settings::Transcode::Mode::Always);
-			_transcodeModeModel->add(Wt::WString::tr("Lms.Settings.transcode-mode.never"), MediaPlayer::Settings::Transcode::Mode::Never);
-			_transcodeModeModel->add(Wt::WString::tr("Lms.Settings.transcode-mode.if-format-not-supported"), MediaPlayer::Settings::Transcode::Mode::IfFormatNotSupported);
-
-			_transcodeBitrateModel = std::make_shared<ValueStringModel<Bitrate>>();
-			visitAllowedAudioBitrates([&](const Bitrate bitrate)
-			{
-				_transcodeBitrateModel->add(Wt::WString::fromUTF8(std::to_string(bitrate / 1000)), bitrate);
-			});
-
-			_transcodeFormatModel = std::make_shared<ValueStringModel<AudioFormat>>();
-			_transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcode-format.mp3"), AudioFormat::MP3);
-			_transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcode-format.ogg_opus"), AudioFormat::OGG_OPUS);
-			_transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcode-format.matroska_opus"), AudioFormat::MATROSKA_OPUS);
-			_transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcode-format.ogg_vorbis"), AudioFormat::OGG_VORBIS);
-			_transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcode-format.webm_vorbis"), AudioFormat::WEBM_VORBIS);
-
-			_replayGainModeModel = std::make_shared<ReplayGainModeModel>();
-			_replayGainModeModel->add(Wt::WString::tr("Lms.Settings.replaygain-mode.none"), MediaPlayer::Settings::ReplayGain::Mode::None);
-			_replayGainModeModel->add(Wt::WString::tr("Lms.Settings.replaygain-mode.auto"), MediaPlayer::Settings::ReplayGain::Mode::Auto);
-			_replayGainModeModel->add(Wt::WString::tr("Lms.Settings.replaygain-mode.track"), MediaPlayer::Settings::ReplayGain::Mode::Track);
-			_replayGainModeModel->add(Wt::WString::tr("Lms.Settings.replaygain-mode.release"), MediaPlayer::Settings::ReplayGain::Mode::Release);
-
-			_subsonicArtistListModeModel = std::make_shared<ValueStringModel<SubsonicArtistListMode>>();
-			_subsonicArtistListModeModel->add(Wt::WString::tr("Lms.Settings.subsonic-artist-list-mode.all-artists"), SubsonicArtistListMode::AllArtists);
-			_subsonicArtistListModeModel->add(Wt::WString::tr("Lms.Settings.subsonic-artist-list-mode.release-artists"), SubsonicArtistListMode::ReleaseArtists);
-			_subsonicArtistListModeModel->add(Wt::WString::tr("Lms.Settings.subsonic-artist-list-mode.track-artists"), SubsonicArtistListMode::TrackArtists);
-
-			_scrobblerModel = std::make_shared<ValueStringModel<Scrobbler>>();
-			_scrobblerModel->add(Wt::WString::tr("Lms.Settings.scrobbling.scrobbler.internal"), Scrobbler::Internal);
-			_scrobblerModel->add(Wt::WString::tr("Lms.Settings.scrobbling.scrobbler.listenbrainz"), Scrobbler::ListenBrainz);
-		}
-
-		::Auth::IPasswordService* _authPasswordService {};
-		bool _withOldPassword {};
-
-		std::shared_ptr<TranscodeModeModel>					_transcodeModeModel;
-		std::shared_ptr<ValueStringModel<Bitrate>>			_transcodeBitrateModel;
-		std::shared_ptr<ValueStringModel<AudioFormat>>		_transcodeFormatModel;
-		std::shared_ptr<ReplayGainModeModel>				_replayGainModeModel;
-		std::shared_ptr<ValueStringModel<SubsonicArtistListMode>> _subsonicArtistListModeModel;
-		std::shared_ptr<ScrobblerModel> 					_scrobblerModel;
-};
-
-SettingsView::SettingsView()
-{
-	wApp->internalPathChanged().connect(this, [this]
-	{
-		refreshView();
-	});
-
-	LmsApp->getMediaPlayer().settingsLoaded.connect([this]
-	{
-		refreshView();
-	});
-
-	refreshView();
-}
-
-void
-SettingsView::refreshView()
-{
-	if (!wApp->internalPathMatches("/settings"))
-		return;
-
-	clear();
-
-	// Hack to wait for the audio player know the settings applied
-	if (!LmsApp->getMediaPlayer().getSettings())
-		return;
-
-	auto t {addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.Settings.template"))};
-
-	auto* authPasswordService {Service<::Auth::IPasswordService>::get()};
-	if (authPasswordService && !authPasswordService->canSetPasswords())
-		authPasswordService = nullptr;
-
-	auto model {std::make_shared<SettingsModel>(authPasswordService, !LmsApp->isUserAuthStrong())};
-
-	if (authPasswordService)
-	{
-		t->setCondition("if-has-change-password", true);
-
-		// Old password
-		if (!LmsApp->isUserAuthStrong())
-		{
-			t->setCondition("if-has-old-password", true);
-
-			auto oldPassword {std::make_unique<Wt::WLineEdit>()};
-			oldPassword->setEchoMode(Wt::EchoMode::Password);
-			oldPassword->setAttributeValue("autocomplete", "current-password");
-			t->setFormWidget(SettingsModel::PasswordOldField, std::move(oldPassword));
-		}
-
-		// Password
-		auto password {std::make_unique<Wt::WLineEdit>()};
-		password->setEchoMode(Wt::EchoMode::Password);
-		password->setAttributeValue("autocomplete", "new-password");
-		t->setFormWidget(SettingsModel::PasswordField, std::move(password));
-
-		// Password confirm
-		auto passwordConfirm {std::make_unique<Wt::WLineEdit>()};
-		passwordConfirm->setEchoMode(Wt::EchoMode::Password);
-		passwordConfirm->setAttributeValue("autocomplete", "new-password");
-		t->setFormWidget(SettingsModel::PasswordConfirmField, std::move(passwordConfirm));
-	}
-
-	// Audio
-	{
-		// Transcode
-		auto transcodeMode {std::make_unique<Wt::WComboBox>()};
-		auto* transcodeModeRaw {transcodeMode.get()};
-		transcodeMode->setModel(model->getTranscodeModeModel());
-		t->setFormWidget(SettingsModel::TranscodeModeField, std::move(transcodeMode));
-
-		// Format
-		auto transcodeFormat {std::make_unique<Wt::WComboBox>()};
-		transcodeFormat->setModel(model->getTranscodeFormatModel());
-		t->setFormWidget(SettingsModel::TranscodeFormatField, std::move(transcodeFormat));
-
-		// Bitrate
-		auto transcodeBitrate {std::make_unique<Wt::WComboBox>()};
-		transcodeBitrate->setModel(model->getTranscodeBitrateModel());
-		t->setFormWidget(SettingsModel::TranscodeBitrateField, std::move(transcodeBitrate));
-
-		transcodeModeRaw->activated().connect([=](int row)
-		{
-			const bool enable {model->getTranscodeModeModel()->getValue(row) != MediaPlayer::Settings::Transcode::Mode::Never};
-			model->setReadOnly(SettingsModel::TranscodeFormatField, !enable);
-			model->setReadOnly(SettingsModel::TranscodeBitrateField, !enable);
-			t->updateModel(model.get());
-			t->updateView(model.get());
-		});
-
-		// Replay gain mode
-		auto replayGainMode {std::make_unique<Wt::WComboBox>()};
-		auto* replayGainModeRaw {replayGainMode.get()};
-		replayGainMode->setModel(model->getReplayGainModeModel());
-		t->setFormWidget(SettingsModel::ReplayGainModeField, std::move(replayGainMode));
-
-		// Replay gain preampGain
-		auto replayGainPreampGain {std::make_unique<Wt::WDoubleSpinBox>()};
-		replayGainPreampGain->setRange(MediaPlayer::Settings::ReplayGain::minPreAmpGain, MediaPlayer::Settings::ReplayGain::maxPreAmpGain);
-		t->setFormWidget(SettingsModel::ReplayGainPreAmpGainField, std::move(replayGainPreampGain));
-
-		// Replay gain preampGain if no info
-		auto replayGainPreampGainIfNoInfo {std::make_unique<Wt::WDoubleSpinBox>()};
-		replayGainPreampGainIfNoInfo->setRange(MediaPlayer::Settings::ReplayGain::minPreAmpGain, MediaPlayer::Settings::ReplayGain::maxPreAmpGain);
-		t->setFormWidget(SettingsModel::ReplayGainPreAmpGainIfNoInfoField, std::move(replayGainPreampGainIfNoInfo));
-
-		replayGainModeRaw->activated().connect([=](int row)
-		{
-			const bool enable {model->getReplayGainModeModel()->getValue(row) != MediaPlayer::Settings::ReplayGain::Mode::None};
-			model->setReadOnly(SettingsModel::SettingsModel::ReplayGainPreAmpGainField, !enable);
-			model->setReadOnly(SettingsModel::SettingsModel::ReplayGainPreAmpGainIfNoInfoField, !enable);
-			t->updateModel(model.get());
-			t->updateView(model.get());
-		});
-		if (LmsApp->getMediaPlayer().getSettings()->replayGain.mode == MediaPlayer::Settings::ReplayGain::Mode::None)
-		{
-			model->setReadOnly(SettingsModel::SettingsModel::ReplayGainPreAmpGainField, true);
-			model->setReadOnly(SettingsModel::SettingsModel::ReplayGainPreAmpGainIfNoInfoField, true);
-		}
-	}
-
-	// Subsonic
-	{
-		t->setCondition("if-has-subsonic-api", Service<IConfig>::get()->getBool("api-subsonic", true));
-
-		// Format
-		auto transcodeFormat {std::make_unique<Wt::WComboBox>()};
-		transcodeFormat->setModel(model->getTranscodeFormatModel());
-		t->setFormWidget(SettingsModel::SubsonicTranscodeFormatField, std::move(transcodeFormat));
-
-		// Bitrate
-		auto transcodeBitrate {std::make_unique<Wt::WComboBox>()};
-		transcodeBitrate->setModel(model->getTranscodeBitrateModel());
-		t->setFormWidget(SettingsModel::SubsonicTranscodeBitrateField, std::move(transcodeBitrate));
-
-		// Artist list mode
-		auto artistListMode {std::make_unique<Wt::WComboBox>()};
-		artistListMode->setModel(model->getSubsonicArtistListModeModel());
-		t->setFormWidget(SettingsModel::SubsonicArtistListModeField, std::move(artistListMode));
-	}
-
-	// Scrobbling
-	{
-		auto scrobbler {std::make_unique<Wt::WComboBox>()};
-		scrobbler->setModel(model->getScrobblerModel());
-		auto* scrobblerRaw {scrobbler.get()};
-		t->setFormWidget(SettingsModel::ScrobblerField, std::move(scrobbler));
-
-		auto listenbrainzToken {std::make_unique<Wt::WLineEdit>()};
-		t->setFormWidget(SettingsModel::ListenBrainzTokenField, std::move(listenbrainzToken));
-		scrobblerRaw->activated().connect([=](int row)
-		{
-			const bool enable {model->getScrobblerModel()->getValue(row) == Scrobbler::ListenBrainz};
-			model->setReadOnly(SettingsModel::ListenBrainzTokenField, !enable);
-			model->validator(SettingsModel::ListenBrainzTokenField)->setMandatory(enable);
-			t->updateModel(model.get());
-			t->updateView(model.get());
-		});
-	}
-
-	// Buttons
-	Wt::WPushButton *saveBtn {t->bindWidget("apply-btn", std::make_unique<Wt::WPushButton>(Wt::WString::tr("Lms.apply")))};
-	Wt::WPushButton *discardBtn {t->bindWidget("discard-btn", std::make_unique<Wt::WPushButton>(Wt::WString::tr("Lms.discard")))};
-
-	saveBtn->clicked().connect([=]
-	{
-		{
-			auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-
-			if (LmsApp->getUser()->isDemo())
-			{
-				LmsApp->notifyMsg(Notification::Type::Warning, Wt::WString::tr("Lms.Settings.settings"), Wt::WString::tr("Lms.Settings.demo-cannot-save"));
-				return;
-			}
-		}
-
-		t->updateModel(model.get());
-
-		if (model->validate())
-		{
-			model->saveData();
-			LmsApp->notifyMsg(Notification::Type::Info, Wt::WString::tr("Lms.Settings.settings"), Wt::WString::tr("Lms.Settings.settings-saved"));
-		}
-
-		// Udate the view: Delete any validation message in the view, etc.
-		t->updateView(model.get());
-	});
-
-	discardBtn->clicked().connect([=]
-	{
-		model->loadData();
-		model->validate();
-		t->updateView(model.get());
-	});
-
-	t->updateView(model.get());
-}
-
-} // namespace UserInterface
-
-
+    using namespace Database;
+
+    class SettingsModel : public Wt::WFormModel
+    {
+    public:
+        // Associate each field with a unique string literal.
+        static inline const Field TranscodeModeField{ "transcode-mode" };
+        static inline const Field TranscodeFormatField{ "transcode-format" };
+        static inline const Field TranscodeBitrateField{ "transcode-bitrate" };
+        static inline const Field ReplayGainModeField{ "replaygain-mode" };
+        static inline const Field ReplayGainPreAmpGainField{ "replaygain-preamp" };
+        static inline const Field ReplayGainPreAmpGainIfNoInfoField{ "replaygain-preamp-no-rg-info" };
+        static inline const Field SubsonicArtistListModeField{ "subsonic-artist-list-mode" };
+        static inline const Field SubsonicTranscodeFormatField{ "subsonic-transcode-format" };
+        static inline const Field SubsonicTranscodeBitrateField{ "subsonic-transcode-bitrate" };
+        static inline const Field FeedbackBackendField{ "feedback-backend" };
+        static inline const Field ScrobblingBackendField{ "scrobbling-backend" };
+        static inline const Field ListenBrainzTokenField{ "listenbrainz-token" };
+        static inline const Field PasswordOldField{ "password-old" };
+        static inline const Field PasswordField{ "password" };
+        static inline const Field PasswordConfirmField{ "password-confirm" };
+
+        using TranscodeModeModel = ValueStringModel<MediaPlayer::Settings::Transcode::Mode>;
+        using ReplayGainModeModel = ValueStringModel<MediaPlayer::Settings::ReplayGain::Mode>;
+        using FeedbackBackendModel = ValueStringModel<FeedbackBackend>;
+        using ScrobblingBackendModel = ValueStringModel<ScrobblingBackend>;
+
+        SettingsModel(::Auth::IPasswordService* authPasswordService, bool withOldPassword)
+            : _authPasswordService{ authPasswordService }
+            , _withOldPassword{ withOldPassword }
+        {
+            initializeModels();
+
+            addField(TranscodeModeField);
+            addField(TranscodeBitrateField);
+            addField(TranscodeFormatField);
+            addField(ReplayGainModeField);
+            addField(ReplayGainPreAmpGainField);
+            addField(ReplayGainPreAmpGainIfNoInfoField);
+            addField(SubsonicTranscodeBitrateField);
+            addField(SubsonicTranscodeFormatField);
+            addField(FeedbackBackendField);
+            addField(ScrobblingBackendField);
+            addField(ListenBrainzTokenField);
+            setValidator(ListenBrainzTokenField, createUUIDValidator());
+
+            if (_authPasswordService)
+            {
+                if (_withOldPassword)
+                {
+                    addField(PasswordOldField);
+                    setValidator(PasswordOldField, createPasswordCheckValidator());
+                }
+
+                addField(PasswordField);
+                setValidator(PasswordField, createPasswordStrengthValidator([] { return ::Auth::PasswordValidationContext{ LmsApp->getUserLoginName(), LmsApp->getUserType() }; }));
+                addField(PasswordConfirmField);
+            }
+
+            setValidator(TranscodeModeField, createMandatoryValidator());
+            setValidator(TranscodeBitrateField, createMandatoryValidator());
+            setValidator(TranscodeFormatField, createMandatoryValidator());
+            setValidator(ReplayGainModeField, createMandatoryValidator());
+            auto createPreAmpValidator{ []
+            {
+                return createDoubleValidator(MediaPlayer::Settings::ReplayGain::minPreAmpGain, MediaPlayer::Settings::ReplayGain::maxPreAmpGain);
+            } };
+
+            setValidator(ReplayGainPreAmpGainField, createPreAmpValidator());
+            setValidator(ReplayGainPreAmpGainIfNoInfoField, createPreAmpValidator());
+            setValidator(SubsonicTranscodeBitrateField, createMandatoryValidator());
+            setValidator(SubsonicTranscodeFormatField, createMandatoryValidator());
+
+            loadData();
+        }
+
+        std::shared_ptr<TranscodeModeModel>		getTranscodeModeModel() { return _transcodeModeModel; }
+        std::shared_ptr<Wt::WAbstractItemModel>	getTranscodeBitrateModel() { return _transcodeBitrateModel; }
+        std::shared_ptr<Wt::WAbstractItemModel>	getTranscodeFormatModel() { return _transcodeFormatModel; }
+        std::shared_ptr<ReplayGainModeModel>	getReplayGainModeModel() { return _replayGainModeModel; }
+        std::shared_ptr<Wt::WAbstractItemModel>	getSubsonicArtistListModeModel() { return _subsonicArtistListModeModel; }
+        std::shared_ptr<FeedbackBackendModel>	getFeedbackBackendModel() { return _feedbackBackendModel; }
+        std::shared_ptr<ScrobblingBackendModel>	getScrobblingBackendModel() { return _scrobblingBackendModel; }
+
+        void saveData()
+        {
+            auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
+
+            User::pointer user{ LmsApp->getUser() };
+
+            {
+                MediaPlayer::Settings settings;
+
+                auto transcodeModeRow{ _transcodeModeModel->getRowFromString(valueText(TranscodeModeField)) };
+                if (transcodeModeRow)
+                    settings.transcode.mode = _transcodeModeModel->getValue(*transcodeModeRow);
+
+                auto transcodeFormatRow{ _transcodeFormatModel->getRowFromString(valueText(TranscodeFormatField)) };
+                if (transcodeFormatRow)
+                    settings.transcode.format = _transcodeFormatModel->getValue(*transcodeFormatRow);
+
+                auto transcodeBitrateRow{ _transcodeBitrateModel->getRowFromString(valueText(TranscodeBitrateField)) };
+                if (transcodeBitrateRow)
+                    settings.transcode.bitrate = _transcodeBitrateModel->getValue(*transcodeBitrateRow);
+
+                auto replayGainModeRow{ _replayGainModeModel->getRowFromString(valueText(ReplayGainModeField)) };
+                if (replayGainModeRow)
+                    settings.replayGain.mode = _replayGainModeModel->getValue(*replayGainModeRow);
+
+                settings.replayGain.preAmpGain = Wt::asNumber(value(ReplayGainPreAmpGainField));
+                settings.replayGain.preAmpGainIfNoInfo = Wt::asNumber(value(ReplayGainPreAmpGainIfNoInfoField));
+
+                LmsApp->getMediaPlayer().setSettings(settings);
+            }
+
+            {
+                auto subsonicTranscodeBitrateRow{ _transcodeBitrateModel->getRowFromString(valueText(SubsonicTranscodeBitrateField)) };
+                if (subsonicTranscodeBitrateRow)
+                    user.modify()->setSubsonicDefaultTranscodeBitrate(_transcodeBitrateModel->getValue(*subsonicTranscodeBitrateRow));
+
+                auto subsonicTranscodeFormatRow{ _transcodeFormatModel->getRowFromString(valueText(SubsonicTranscodeFormatField)) };
+                if (subsonicTranscodeFormatRow)
+                    user.modify()->setSubsonicDefaultTranscodeFormat(_transcodeFormatModel->getValue(*subsonicTranscodeFormatRow));
+
+                auto subsonicArtistListModeRow{ _subsonicArtistListModeModel->getRowFromString(valueText(SubsonicArtistListModeField)) };
+                if (subsonicArtistListModeRow)
+                    user.modify()->setSubsonicArtistListMode(_subsonicArtistListModeModel->getValue(*subsonicArtistListModeRow));
+
+            }
+
+            {
+                if (auto feedbackBackendRow{ _feedbackBackendModel->getRowFromString(valueText(FeedbackBackendField)) })
+                    user.modify()->setFeedbackBackend(_feedbackBackendModel->getValue(*feedbackBackendRow));
+
+                user.modify()->setListenBrainzToken(UUID::fromString(Wt::asString(value(ListenBrainzTokenField)).toUTF8()));
+            }
+
+            {
+                if (auto scrobblingBackendRow{ _scrobblingBackendModel->getRowFromString(valueText(ScrobblingBackendField)) })
+                    user.modify()->setScrobblingBackend(_scrobblingBackendModel->getValue(*scrobblingBackendRow));
+
+                user.modify()->setListenBrainzToken(UUID::fromString(Wt::asString(value(ListenBrainzTokenField)).toUTF8()));
+            }
+
+            if (_authPasswordService && !valueText(PasswordField).empty())
+            {
+                _authPasswordService->setPassword(user->getId(), valueText(PasswordField).toUTF8());
+            }
+        }
+
+        void loadData()
+        {
+            auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+
+            User::pointer user{ LmsApp->getUser() };
+
+            {
+                const auto settings{ *LmsApp->getMediaPlayer().getSettings() };
+
+                auto transcodeModeRow{ _transcodeModeModel->getRowFromValue(settings.transcode.mode) };
+                if (transcodeModeRow)
+                    setValue(TranscodeModeField, _transcodeModeModel->getString(*transcodeModeRow));
+
+                auto transcodeFormatRow{ _transcodeFormatModel->getRowFromValue(settings.transcode.format) };
+                if (transcodeFormatRow)
+                    setValue(TranscodeFormatField, _transcodeFormatModel->getString(*transcodeFormatRow));
+
+                auto transcodeBitrateRow{ _transcodeBitrateModel->getRowFromValue(settings.transcode.bitrate) };
+                if (transcodeBitrateRow)
+                    setValue(TranscodeBitrateField, _transcodeBitrateModel->getString(*transcodeBitrateRow));
+
+                {
+                    const bool usesTranscode{ settings.transcode.mode != MediaPlayer::Settings::Transcode::Mode::Never };
+                    setReadOnly(SettingsModel::TranscodeFormatField, !usesTranscode);
+                    setReadOnly(SettingsModel::TranscodeBitrateField, !usesTranscode);
+                }
+
+                auto replayGainModeRow{ _replayGainModeModel->getRowFromValue(settings.replayGain.mode) };
+                if (replayGainModeRow)
+                    setValue(ReplayGainModeField, _replayGainModeModel->getString(*replayGainModeRow));
+
+                setValue(ReplayGainPreAmpGainField, settings.replayGain.preAmpGain);
+                setValue(ReplayGainPreAmpGainIfNoInfoField, settings.replayGain.preAmpGainIfNoInfo);
+            }
+
+            {
+                auto subsonicTranscodeBitrateRow{ _transcodeBitrateModel->getRowFromValue(user->getSubsonicDefaultTranscodeBitrate()) };
+                if (subsonicTranscodeBitrateRow)
+                    setValue(SubsonicTranscodeBitrateField, _transcodeBitrateModel->getString(*subsonicTranscodeBitrateRow));
+
+                auto subsonicTranscodeFormatRow{ _transcodeFormatModel->getRowFromValue(user->getSubsonicDefaultTranscodeFormat()) };
+                if (subsonicTranscodeFormatRow)
+                    setValue(SubsonicTranscodeFormatField, _transcodeFormatModel->getString(*subsonicTranscodeFormatRow));
+
+                auto subsonicArtistListModeRow{ _subsonicArtistListModeModel->getRowFromValue(user->getSubsonicArtistListMode()) };
+                if (subsonicArtistListModeRow)
+                    setValue(SubsonicArtistListModeField, _subsonicArtistListModeModel->getString(*subsonicArtistListModeRow));
+            }
+
+            {
+                if (auto feedbackBackendRow{ _feedbackBackendModel->getRowFromValue(user->getFeedbackBackend()) })
+                    setValue(FeedbackBackendField, _feedbackBackendModel->getString(*feedbackBackendRow));
+
+                if (auto scrobblingBackendRow{ _scrobblingBackendModel->getRowFromValue(user->getScrobblingBackend()) })
+                    setValue(ScrobblingBackendField, _scrobblingBackendModel->getString(*scrobblingBackendRow));
+
+                if (auto listenBrainzToken{ user->getListenBrainzToken() })
+                {
+                    LMS_LOG(UI, DEBUG) << "Read listenBrainzToken! value = " << listenBrainzToken->getAsString();
+                    setValue(ListenBrainzTokenField, Wt::WString::fromUTF8(std::string{ listenBrainzToken->getAsString() }));
+                }
+
+                {
+                    const bool usesListenBrainz{ user->getScrobblingBackend() == ScrobblingBackend::ListenBrainz || user->getFeedbackBackend() == FeedbackBackend::ListenBrainz};
+                    setReadOnly(SettingsModel::ListenBrainzTokenField, !usesListenBrainz);
+                    validator(SettingsModel::ListenBrainzTokenField)->setMandatory(usesListenBrainz);
+                }
+            }
+            if (_authPasswordService)
+            {
+                if (_withOldPassword)
+                    setValue(PasswordOldField, "");
+
+                setValue(PasswordField, "");
+                setValue(PasswordConfirmField, "");
+            }
+        }
+
+    private:
+        bool validateField(Field field)
+        {
+            Wt::WString error;
+
+            if (field == PasswordOldField)
+            {
+                if (valueText(PasswordOldField).empty() && !valueText(PasswordField).empty())
+                    error = Wt::WString::tr("Lms.Settings.password-must-fill-old-password");
+                else
+                    return Wt::WFormModel::validateField(field);
+            }
+            else if (field == PasswordField)
+            {
+                if (!valueText(PasswordOldField).empty() && valueText(PasswordField).empty())
+                    error = Wt::WString::tr("Wt.WValidator.Invalid");
+                else
+                    return Wt::WFormModel::validateField(field);
+            }
+            else if (field == PasswordConfirmField)
+            {
+                if (validation(PasswordField).state() == Wt::ValidationState::Valid)
+                {
+                    if (valueText(PasswordField) != valueText(PasswordConfirmField))
+                        error = Wt::WString::tr("Lms.passwords-dont-match");
+                }
+            }
+            else
+            {
+                return Wt::WFormModel::validateField(field);
+            }
+
+            setValidation(field, Wt::WValidator::Result(error.empty() ? Wt::ValidationState::Valid : Wt::ValidationState::Invalid, error));
+
+            return (validation(field).state() == Wt::ValidationState::Valid);
+        }
+
+    private:
+
+        void initializeModels()
+        {
+            _transcodeModeModel = std::make_shared<TranscodeModeModel>();
+            _transcodeModeModel->add(Wt::WString::tr("Lms.Settings.transcode-mode.always"), MediaPlayer::Settings::Transcode::Mode::Always);
+            _transcodeModeModel->add(Wt::WString::tr("Lms.Settings.transcode-mode.never"), MediaPlayer::Settings::Transcode::Mode::Never);
+            _transcodeModeModel->add(Wt::WString::tr("Lms.Settings.transcode-mode.if-format-not-supported"), MediaPlayer::Settings::Transcode::Mode::IfFormatNotSupported);
+
+            _transcodeBitrateModel = std::make_shared<ValueStringModel<Bitrate>>();
+            visitAllowedAudioBitrates([&](const Bitrate bitrate)
+                {
+                    _transcodeBitrateModel->add(Wt::WString::fromUTF8(std::to_string(bitrate / 1000)), bitrate);
+                });
+
+            _transcodeFormatModel = std::make_shared<ValueStringModel<AudioFormat>>();
+            _transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcode-format.mp3"), AudioFormat::MP3);
+            _transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcode-format.ogg_opus"), AudioFormat::OGG_OPUS);
+            _transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcode-format.matroska_opus"), AudioFormat::MATROSKA_OPUS);
+            _transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcode-format.ogg_vorbis"), AudioFormat::OGG_VORBIS);
+            _transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcode-format.webm_vorbis"), AudioFormat::WEBM_VORBIS);
+
+            _replayGainModeModel = std::make_shared<ReplayGainModeModel>();
+            _replayGainModeModel->add(Wt::WString::tr("Lms.Settings.replaygain-mode.none"), MediaPlayer::Settings::ReplayGain::Mode::None);
+            _replayGainModeModel->add(Wt::WString::tr("Lms.Settings.replaygain-mode.auto"), MediaPlayer::Settings::ReplayGain::Mode::Auto);
+            _replayGainModeModel->add(Wt::WString::tr("Lms.Settings.replaygain-mode.track"), MediaPlayer::Settings::ReplayGain::Mode::Track);
+            _replayGainModeModel->add(Wt::WString::tr("Lms.Settings.replaygain-mode.release"), MediaPlayer::Settings::ReplayGain::Mode::Release);
+
+            _subsonicArtistListModeModel = std::make_shared<ValueStringModel<SubsonicArtistListMode>>();
+            _subsonicArtistListModeModel->add(Wt::WString::tr("Lms.Settings.subsonic-artist-list-mode.all-artists"), SubsonicArtistListMode::AllArtists);
+            _subsonicArtistListModeModel->add(Wt::WString::tr("Lms.Settings.subsonic-artist-list-mode.release-artists"), SubsonicArtistListMode::ReleaseArtists);
+            _subsonicArtistListModeModel->add(Wt::WString::tr("Lms.Settings.subsonic-artist-list-mode.track-artists"), SubsonicArtistListMode::TrackArtists);
+
+            _feedbackBackendModel = std::make_shared<ValueStringModel<FeedbackBackend>>();
+            _feedbackBackendModel->add(Wt::WString::tr("Lms.Settings.backend.internal"), FeedbackBackend::Internal);
+            _feedbackBackendModel->add(Wt::WString::tr("Lms.Settings.backend.listenbrainz"), FeedbackBackend::ListenBrainz);
+
+            _scrobblingBackendModel = std::make_shared<ValueStringModel<ScrobblingBackend>>();
+            _scrobblingBackendModel->add(Wt::WString::tr("Lms.Settings.backend.internal"), ScrobblingBackend::Internal);
+            _scrobblingBackendModel->add(Wt::WString::tr("Lms.Settings.backend.listenbrainz"), ScrobblingBackend::ListenBrainz);
+        }
+
+        ::Auth::IPasswordService* _authPasswordService{};
+        bool _withOldPassword{};
+
+        std::shared_ptr<TranscodeModeModel>					_transcodeModeModel;
+        std::shared_ptr<ValueStringModel<Bitrate>>			_transcodeBitrateModel;
+        std::shared_ptr<ValueStringModel<AudioFormat>>		_transcodeFormatModel;
+        std::shared_ptr<ReplayGainModeModel>				_replayGainModeModel;
+        std::shared_ptr<ValueStringModel<SubsonicArtistListMode>> _subsonicArtistListModeModel;
+        std::shared_ptr<FeedbackBackendModel> 			    _feedbackBackendModel;
+        std::shared_ptr<ScrobblingBackendModel> 			_scrobblingBackendModel;
+    };
+
+    SettingsView::SettingsView()
+    {
+        wApp->internalPathChanged().connect(this, [this]
+            {
+                refreshView();
+            });
+
+        LmsApp->getMediaPlayer().settingsLoaded.connect([this]
+            {
+                refreshView();
+            });
+
+        refreshView();
+    }
+
+    void
+        SettingsView::refreshView()
+    {
+        if (!wApp->internalPathMatches("/settings"))
+            return;
+
+        clear();
+
+        // Hack to wait for the audio player know the settings applied
+        if (!LmsApp->getMediaPlayer().getSettings())
+            return;
+
+        auto t{ addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.Settings.template")) };
+
+        auto* authPasswordService{ Service<::Auth::IPasswordService>::get() };
+        if (authPasswordService && !authPasswordService->canSetPasswords())
+            authPasswordService = nullptr;
+
+        auto model{ std::make_shared<SettingsModel>(authPasswordService, !LmsApp->isUserAuthStrong()) };
+
+        if (authPasswordService)
+        {
+            t->setCondition("if-has-change-password", true);
+
+            // Old password
+            if (!LmsApp->isUserAuthStrong())
+            {
+                t->setCondition("if-has-old-password", true);
+
+                auto oldPassword{ std::make_unique<Wt::WLineEdit>() };
+                oldPassword->setEchoMode(Wt::EchoMode::Password);
+                oldPassword->setAttributeValue("autocomplete", "current-password");
+                t->setFormWidget(SettingsModel::PasswordOldField, std::move(oldPassword));
+            }
+
+            // Password
+            auto password{ std::make_unique<Wt::WLineEdit>() };
+            password->setEchoMode(Wt::EchoMode::Password);
+            password->setAttributeValue("autocomplete", "new-password");
+            t->setFormWidget(SettingsModel::PasswordField, std::move(password));
+
+            // Password confirm
+            auto passwordConfirm{ std::make_unique<Wt::WLineEdit>() };
+            passwordConfirm->setEchoMode(Wt::EchoMode::Password);
+            passwordConfirm->setAttributeValue("autocomplete", "new-password");
+            t->setFormWidget(SettingsModel::PasswordConfirmField, std::move(passwordConfirm));
+        }
+
+        // Audio
+        {
+            // Transcode
+            auto transcodeMode{ std::make_unique<Wt::WComboBox>() };
+            auto* transcodeModeRaw{ transcodeMode.get() };
+            transcodeMode->setModel(model->getTranscodeModeModel());
+            t->setFormWidget(SettingsModel::TranscodeModeField, std::move(transcodeMode));
+
+            // Format
+            auto transcodeFormat{ std::make_unique<Wt::WComboBox>() };
+            transcodeFormat->setModel(model->getTranscodeFormatModel());
+            t->setFormWidget(SettingsModel::TranscodeFormatField, std::move(transcodeFormat));
+
+            // Bitrate
+            auto transcodeBitrate{ std::make_unique<Wt::WComboBox>() };
+            transcodeBitrate->setModel(model->getTranscodeBitrateModel());
+            t->setFormWidget(SettingsModel::TranscodeBitrateField, std::move(transcodeBitrate));
+
+            transcodeModeRaw->activated().connect([=](int row)
+                {
+                    const bool enable{ model->getTranscodeModeModel()->getValue(row) != MediaPlayer::Settings::Transcode::Mode::Never };
+                    model->setReadOnly(SettingsModel::TranscodeFormatField, !enable);
+                    model->setReadOnly(SettingsModel::TranscodeBitrateField, !enable);
+                    t->updateModel(model.get());
+                    t->updateView(model.get());
+                });
+
+            // Replay gain mode
+            auto replayGainMode{ std::make_unique<Wt::WComboBox>() };
+            auto* replayGainModeRaw{ replayGainMode.get() };
+            replayGainMode->setModel(model->getReplayGainModeModel());
+            t->setFormWidget(SettingsModel::ReplayGainModeField, std::move(replayGainMode));
+
+            // Replay gain preampGain
+            auto replayGainPreampGain{ std::make_unique<Wt::WDoubleSpinBox>() };
+            replayGainPreampGain->setRange(MediaPlayer::Settings::ReplayGain::minPreAmpGain, MediaPlayer::Settings::ReplayGain::maxPreAmpGain);
+            t->setFormWidget(SettingsModel::ReplayGainPreAmpGainField, std::move(replayGainPreampGain));
+
+            // Replay gain preampGain if no info
+            auto replayGainPreampGainIfNoInfo{ std::make_unique<Wt::WDoubleSpinBox>() };
+            replayGainPreampGainIfNoInfo->setRange(MediaPlayer::Settings::ReplayGain::minPreAmpGain, MediaPlayer::Settings::ReplayGain::maxPreAmpGain);
+            t->setFormWidget(SettingsModel::ReplayGainPreAmpGainIfNoInfoField, std::move(replayGainPreampGainIfNoInfo));
+
+            replayGainModeRaw->activated().connect([=](int row)
+                {
+                    const bool enable{ model->getReplayGainModeModel()->getValue(row) != MediaPlayer::Settings::ReplayGain::Mode::None };
+                    model->setReadOnly(SettingsModel::SettingsModel::ReplayGainPreAmpGainField, !enable);
+                    model->setReadOnly(SettingsModel::SettingsModel::ReplayGainPreAmpGainIfNoInfoField, !enable);
+                    t->updateModel(model.get());
+                    t->updateView(model.get());
+                });
+            if (LmsApp->getMediaPlayer().getSettings()->replayGain.mode == MediaPlayer::Settings::ReplayGain::Mode::None)
+            {
+                model->setReadOnly(SettingsModel::SettingsModel::ReplayGainPreAmpGainField, true);
+                model->setReadOnly(SettingsModel::SettingsModel::ReplayGainPreAmpGainIfNoInfoField, true);
+            }
+        }
+
+        // Subsonic
+        {
+            t->setCondition("if-has-subsonic-api", Service<IConfig>::get()->getBool("api-subsonic", true));
+
+            // Format
+            auto transcodeFormat{ std::make_unique<Wt::WComboBox>() };
+            transcodeFormat->setModel(model->getTranscodeFormatModel());
+            t->setFormWidget(SettingsModel::SubsonicTranscodeFormatField, std::move(transcodeFormat));
+
+            // Bitrate
+            auto transcodeBitrate{ std::make_unique<Wt::WComboBox>() };
+            transcodeBitrate->setModel(model->getTranscodeBitrateModel());
+            t->setFormWidget(SettingsModel::SubsonicTranscodeBitrateField, std::move(transcodeBitrate));
+
+            // Artist list mode
+            auto artistListMode{ std::make_unique<Wt::WComboBox>() };
+            artistListMode->setModel(model->getSubsonicArtistListModeModel());
+            t->setFormWidget(SettingsModel::SubsonicArtistListModeField, std::move(artistListMode));
+        }
+
+        // Feedback
+        Wt::WComboBox* feedbackBackendRaw{};
+        {
+            auto feedbackBackend{ std::make_unique<Wt::WComboBox>() };
+            feedbackBackend->setModel(model->getFeedbackBackendModel());
+            feedbackBackendRaw = feedbackBackend.get();
+            t->setFormWidget(SettingsModel::FeedbackBackendField, std::move(feedbackBackend));
+        }
+
+        // Scrobbling
+        Wt::WComboBox* scrobblingBackendRaw;
+        {
+            auto scrobblingBackend{ std::make_unique<Wt::WComboBox>() };
+            scrobblingBackend->setModel(model->getScrobblingBackendModel());
+            scrobblingBackendRaw = scrobblingBackend.get();
+            t->setFormWidget(SettingsModel::ScrobblingBackendField, std::move(scrobblingBackend));
+        }
+
+        // Backend settings
+        {
+            auto listenbrainzToken{ std::make_unique<Wt::WLineEdit>() };
+            t->setFormWidget(SettingsModel::ListenBrainzTokenField, std::move(listenbrainzToken));
+        }
+
+        auto updateListenBrainzTokenField{ [=]
+        {
+            const bool enable{ model->getFeedbackBackendModel()->getValue(feedbackBackendRaw->currentIndex()) == FeedbackBackend::ListenBrainz
+                || model->getScrobblingBackendModel()->getValue(scrobblingBackendRaw->currentIndex()) == ScrobblingBackend::ListenBrainz };
+
+            model->setReadOnly(SettingsModel::ListenBrainzTokenField, !enable);
+            model->validator(SettingsModel::ListenBrainzTokenField)->setMandatory(enable);
+            t->updateModel(model.get());
+            t->updateView(model.get());
+        } };
+
+        feedbackBackendRaw->activated().connect([=] { updateListenBrainzTokenField(); });
+        scrobblingBackendRaw->activated().connect([=] { updateListenBrainzTokenField();});
+
+        // Buttons
+        Wt::WPushButton* saveBtn{ t->bindWidget("apply-btn", std::make_unique<Wt::WPushButton>(Wt::WString::tr("Lms.apply"))) };
+        Wt::WPushButton* discardBtn{ t->bindWidget("discard-btn", std::make_unique<Wt::WPushButton>(Wt::WString::tr("Lms.discard"))) };
+
+        saveBtn->clicked().connect([=]
+            {
+                {
+                    auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+
+                    if (LmsApp->getUser()->isDemo())
+                    {
+                        LmsApp->notifyMsg(Notification::Type::Warning, Wt::WString::tr("Lms.Settings.settings"), Wt::WString::tr("Lms.Settings.demo-cannot-save"));
+                        return;
+                    }
+                }
+
+                t->updateModel(model.get());
+
+                if (model->validate())
+                {
+                    model->saveData();
+                    LmsApp->notifyMsg(Notification::Type::Info, Wt::WString::tr("Lms.Settings.settings"), Wt::WString::tr("Lms.Settings.settings-saved"));
+                }
+
+                // Udate the view: Delete any validation message in the view, etc.
+                t->updateView(model.get());
+            });
+
+        discardBtn->clicked().connect([=]
+            {
+                model->loadData();
+                model->validate();
+                t->updateView(model.get());
+            });
+
+        t->updateView(model.get());
+    }
+
+} // namespace UserInterface
\ No newline at end of file
diff --git a/src/lms/ui/Utils.cpp b/src/lms/ui/Utils.cpp
index 0ea27ebf..12c5fb93 100644
--- a/src/lms/ui/Utils.cpp
+++ b/src/lms/ui/Utils.cpp
@@ -191,7 +191,7 @@ namespace UserInterface::Utils
         params.setRelease(release->getId());
         params.setLinkType(TrackArtistLinkType::ReleaseArtist);
 
-        if (const auto releaseArtists{ Artist::find(LmsApp->getDbSession(), params) }; !releaseArtists.results.empty())
+        if (const auto releaseArtists{ Artist::findIds(LmsApp->getDbSession(), params) }; !releaseArtists.results.empty())
         {
             if (releaseArtists.results.size() == 1 && releaseArtists.results.front() == omitIfMatchThisArtist)
                 return {};
@@ -200,7 +200,7 @@ namespace UserInterface::Utils
         }
 
         params.setLinkType(TrackArtistLinkType::Artist);
-        const auto artists{ Artist::find(LmsApp->getDbSession(), params) };
+        const auto artists{ Artist::findIds(LmsApp->getDbSession(), params) };
         if (artists.results.size() == 1)
         {
             if (artists.results.front() == omitIfMatchThisArtist)
diff --git a/src/lms/ui/admin/DatabaseSettingsView.cpp b/src/lms/ui/admin/DatabaseSettingsView.cpp
index 108664da..38d9877e 100644
--- a/src/lms/ui/admin/DatabaseSettingsView.cpp
+++ b/src/lms/ui/admin/DatabaseSettingsView.cpp
@@ -51,7 +51,7 @@ class DatabaseSettingsModel : public Wt::WFormModel
 		static inline constexpr Field MediaDirectoryField {"media-directory"};
 		static inline constexpr Field UpdatePeriodField {"update-period"};
 		static inline constexpr Field UpdateStartTimeField {"update-start-time"};
-		static inline constexpr Field RecommendationEngineTypeField {"recommendation-engine-type"};
+		static inline constexpr Field SimilarityEngineTypeField {"similarity-engine-type"};
 		static inline constexpr Field ClustersField {"clusters"};
 
 		using UpdatePeriodModel = ValueStringModel<ScanSettings::UpdatePeriod>;
@@ -63,7 +63,7 @@ class DatabaseSettingsModel : public Wt::WFormModel
 			addField(MediaDirectoryField);
 			addField(UpdatePeriodField);
 			addField(UpdateStartTimeField);
-			addField(RecommendationEngineTypeField);
+			addField(SimilarityEngineTypeField);
 			addField(ClustersField);
 
 			auto dirValidator {createDirectoryValidator()};
@@ -72,7 +72,7 @@ class DatabaseSettingsModel : public Wt::WFormModel
 
 			setValidator(UpdatePeriodField, createMandatoryValidator());
 			setValidator(UpdateStartTimeField, createMandatoryValidator());
-			setValidator(RecommendationEngineTypeField, createMandatoryValidator());
+			setValidator(SimilarityEngineTypeField, createMandatoryValidator());
 
 			// populate the model with initial data
 			loadData();
@@ -80,7 +80,7 @@ class DatabaseSettingsModel : public Wt::WFormModel
 
 		std::shared_ptr<UpdatePeriodModel> updatePeriodModel() { return _updatePeriodModel; }
 		std::shared_ptr<Wt::WAbstractItemModel> updateStartTimeModel() { return _updateStartTimeModel; }
-		std::shared_ptr<Wt::WAbstractItemModel> recommendationEngineTypeModel() { return _recommendationEngineTypeModel; }
+		std::shared_ptr<Wt::WAbstractItemModel> similarityEngineTypeModel() { return _similarityEngineTypeModel; }
 
 		void loadData()
 		{
@@ -104,9 +104,9 @@ class DatabaseSettingsModel : public Wt::WFormModel
 				setReadOnly(DatabaseSettingsModel::UpdateStartTimeField, true);
 			}
 
-			auto recommendationEngineTypeRow {_recommendationEngineTypeModel->getRowFromValue(scanSettings->getRecommendationEngineType())};
-			if (recommendationEngineTypeRow)
-				setValue(RecommendationEngineTypeField, _recommendationEngineTypeModel->getString(*recommendationEngineTypeRow));
+			auto similarityEngineTypeRow {_similarityEngineTypeModel->getRowFromValue(scanSettings->getSimilarityEngineType())};
+			if (similarityEngineTypeRow)
+				setValue(SimilarityEngineTypeField, _similarityEngineTypeModel->getString(*similarityEngineTypeRow));
 
 			auto clusterTypes {scanSettings->getClusterTypes()};
 			if (!clusterTypes.empty())
@@ -133,21 +133,14 @@ class DatabaseSettingsModel : public Wt::WFormModel
 			if (startTimeRow)
 				scanSettings.modify()->setUpdateStartTime(_updateStartTimeModel->getValue(*startTimeRow));
 
-			auto recommendationEngineTypeRow {_recommendationEngineTypeModel->getRowFromString(valueText(RecommendationEngineTypeField))};
-			if (recommendationEngineTypeRow)
-				scanSettings.modify()->setRecommendationEngineType(_recommendationEngineTypeModel->getValue(*recommendationEngineTypeRow));
+			auto similarityEngineTypeRow {_similarityEngineTypeModel->getRowFromString(valueText(SimilarityEngineTypeField))};
+			if (similarityEngineTypeRow)
+				scanSettings.modify()->setSimilarityEngineType(_similarityEngineTypeModel->getValue(*similarityEngineTypeRow));
 
 			auto clusterTypes {StringUtils::splitStringCopy(valueText(ClustersField).toUTF8(), " ")};
 			scanSettings.modify()->setClusterTypes(LmsApp->getDbSession(), std::set<std::string>(clusterTypes.begin(), clusterTypes.end()));
 		}
 
-		static ScanSettings::RecommendationEngineType getCurrentRecommendationEngine()
-		{
-			auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-			const ScanSettings::pointer scanSettings {ScanSettings::get(LmsApp->getDbSession())};
-			return scanSettings->getRecommendationEngineType();
-		}
-
 	private:
 		void initializeModels()
 		{
@@ -165,14 +158,14 @@ class DatabaseSettingsModel : public Wt::WFormModel
 				_updateStartTimeModel->add(time.toString(), time);
 			}
 
-			_recommendationEngineTypeModel = std::make_shared<ValueStringModel<ScanSettings::RecommendationEngineType>>();
-			_recommendationEngineTypeModel->add(Wt::WString::tr("Lms.Admin.Database.recommendation-engine-type.clusters"), ScanSettings::RecommendationEngineType::Clusters);
-			_recommendationEngineTypeModel->add(Wt::WString::tr("Lms.Admin.Database.recommendation-engine-type.features"), ScanSettings::RecommendationEngineType::Features);
+			_similarityEngineTypeModel = std::make_shared<ValueStringModel<ScanSettings::SimilarityEngineType>>();
+			_similarityEngineTypeModel->add(Wt::WString::tr("Lms.Admin.Database.similarity-engine-type.clusters"), ScanSettings::SimilarityEngineType::Clusters);
+			_similarityEngineTypeModel->add(Wt::WString::tr("Lms.Admin.Database.similarity-engine-type.none"), ScanSettings::SimilarityEngineType::None);
 		}
 
 		std::shared_ptr<UpdatePeriodModel>											_updatePeriodModel;
 		std::shared_ptr<ValueStringModel<Wt::WTime>>								_updateStartTimeModel;
-		std::shared_ptr<ValueStringModel<ScanSettings::RecommendationEngineType>>	_recommendationEngineTypeModel;
+		std::shared_ptr<ValueStringModel<ScanSettings::SimilarityEngineType>>	_similarityEngineTypeModel;
 };
 
 DatabaseSettingsView::DatabaseSettingsView()
@@ -216,13 +209,10 @@ DatabaseSettingsView::refreshView()
 	updateStartTime->setModel(model->updateStartTimeModel());
 	t->setFormWidget(DatabaseSettingsModel::UpdateStartTimeField, std::move(updateStartTime));
 
-	// recommendation engine type
-	// Hide the settings if the engine is set to clusters, as we don't want users to switch to acoustic features (currently broken)
-	// Otherwise, give the user a way to switch back to clusters
-	t->setCondition("if-has-recommendation-engine", model->getCurrentRecommendationEngine() == ScanSettings::RecommendationEngineType::Features);
-	auto recommendationEngineType {std::make_unique<Wt::WComboBox>()};
-	recommendationEngineType->setModel(model->recommendationEngineTypeModel());
-	t->setFormWidget(DatabaseSettingsModel::RecommendationEngineTypeField, std::move(recommendationEngineType));
+	// Similarity engine type
+	auto similarityEngineType {std::make_unique<Wt::WComboBox>()};
+	similarityEngineType->setModel(model->similarityEngineTypeModel());
+	t->setFormWidget(DatabaseSettingsModel::SimilarityEngineTypeField, std::move(similarityEngineType));
 
 	// Clusters
 	t->setFormWidget(DatabaseSettingsModel::ClustersField, std::make_unique<Wt::WLineEdit>());
diff --git a/src/lms/ui/explore/ArtistCollector.cpp b/src/lms/ui/explore/ArtistCollector.cpp
index 16bfd9c7..67d08238 100644
--- a/src/lms/ui/explore/ArtistCollector.cpp
+++ b/src/lms/ui/explore/ArtistCollector.cpp
@@ -23,6 +23,7 @@
 #include "services/database/Session.hpp"
 #include "services/database/TrackList.hpp"
 #include "services/database/User.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "services/scrobbling/IScrobblingService.hpp"
 #include "utils/Service.hpp"
 #include "Filters.hpp"
@@ -30,107 +31,107 @@
 
 namespace UserInterface
 {
-	using namespace Database;
+    using namespace Database;
 
-	RangeResults<ArtistId>
-	ArtistCollector::get(Database::Range range)
-	{
-		Scrobbling::IScrobblingService& scrobbling {*Service<Scrobbling::IScrobblingService>::get()};
+    RangeResults<ArtistId> ArtistCollector::get(Database::Range range)
+    {
+        Feedback::IFeedbackService& feedbackService{ *Service<Feedback::IFeedbackService>::get() };
+        Scrobbling::IScrobblingService& scrobblingService{ *Service<Scrobbling::IScrobblingService>::get() };
 
-		range = getActualRange(range);
+        RangeResults<ArtistId> artists;
 
-		RangeResults<ArtistId> artists;
-		switch (getMode())
-		{
-			case Mode::Random:
-				artists = getRandomArtists(range);
-				break;
+        range = getActualRange(range);
+        if (range.size == 0)
+            return artists;
 
-			case Mode::Starred:
-				artists = scrobbling.getStarredArtists(LmsApp->getUserId(), getFilters().getClusterIds(), _linkType, ArtistSortMethod::StarredDateDesc, range);
-				break;
+        switch (getMode())
+        {
+        case Mode::Random:
+            artists = getRandomArtists(range);
+            break;
 
-			case Mode::RecentlyPlayed:
-				artists = scrobbling.getRecentArtists(LmsApp->getUserId(), getFilters().getClusterIds(), _linkType, range);
-				break;
+        case Mode::Starred:
+            artists = feedbackService.getStarredArtists(LmsApp->getUserId(), getFilters().getClusterIds(), _linkType, ArtistSortMethod::StarredDateDesc, range);
+            break;
 
-			case Mode::MostPlayed:
-				artists = scrobbling.getTopArtists(LmsApp->getUserId(), getFilters().getClusterIds(), _linkType, range);
-				break;
+        case Mode::RecentlyPlayed:
+            artists = scrobblingService.getRecentArtists(LmsApp->getUserId(), getFilters().getClusterIds(), _linkType, range);
+            break;
 
-			case Mode::RecentlyAdded:
-			{
-				Artist::FindParameters params;
-				params.setClusters(getFilters().getClusterIds());
-				params.setLinkType(_linkType);
-				params.setSortMethod(ArtistSortMethod::LastWritten);
-				params.setRange(range);
+        case Mode::MostPlayed:
+            artists = scrobblingService.getTopArtists(LmsApp->getUserId(), getFilters().getClusterIds(), _linkType, range);
+            break;
 
-				{
-					auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-					artists = Artist::find(LmsApp->getDbSession(), params);
-				}
-				break;
-			}
+        case Mode::RecentlyAdded:
+        {
+            Artist::FindParameters params;
+            params.setClusters(getFilters().getClusterIds());
+            params.setLinkType(_linkType);
+            params.setSortMethod(ArtistSortMethod::LastWritten);
+            params.setRange(range);
 
-			case Mode::Search:
-			{
-				Artist::FindParameters params;
-				params.setClusters(getFilters().getClusterIds());
-				params.setKeywords(getSearchKeywords());
-				params.setLinkType(_linkType);
-				params.setSortMethod(ArtistSortMethod::BySortName);
-				params.setRange(range);
+            {
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                artists = Artist::findIds(LmsApp->getDbSession(), params);
+            }
+            break;
+        }
 
-				{
-					auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-					artists = Artist::find(LmsApp->getDbSession(), params);
-				}
-				break;
-			}
+        case Mode::Search:
+        {
+            Artist::FindParameters params;
+            params.setClusters(getFilters().getClusterIds());
+            params.setKeywords(getSearchKeywords());
+            params.setLinkType(_linkType);
+            params.setRange(range);
 
-			case Mode::All:
-			{
-				Artist::FindParameters params;
-				params.setClusters(getFilters().getClusterIds());
-				params.setLinkType(_linkType);
-				params.setSortMethod(ArtistSortMethod::BySortName);
-				params.setRange(range);
+            {
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                artists = Artist::findIds(LmsApp->getDbSession(), params);
+            }
+            break;
+        }
 
-				{
-					auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-					artists = Artist::find(LmsApp->getDbSession(), params);
-				}
-				break;
-			}
-		}
+        case Mode::All:
+        {
+            Artist::FindParameters params;
+            params.setClusters(getFilters().getClusterIds());
+            params.setLinkType(_linkType);
+            params.setSortMethod(ArtistSortMethod::BySortName);
+            params.setRange(range);
 
-		if (range.offset + range.size == getMaxCount())
-			artists.moreResults = false;
+            {
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                artists = Artist::findIds(LmsApp->getDbSession(), params);
+            }
+            break;
+        }
+        }
 
-		return artists;
-	}
+        if (range.offset + range.size == getMaxCount())
+            artists.moreResults = false;
 
-	RangeResults<Database::ArtistId>
-	ArtistCollector::getRandomArtists(Range range)
-	{
-		assert(getMode() == Mode::Random);
+        return artists;
+    }
 
-		if (!_randomArtists)
-		{
-			Artist::FindParameters params;
-			params.setClusters(getFilters().getClusterIds());
-			params.setLinkType(_linkType);
-			params.setSortMethod(ArtistSortMethod::Random);
-			params.setRange(Range {0, getMaxCount()});
+    RangeResults<Database::ArtistId> ArtistCollector::getRandomArtists(Range range)
+    {
+        assert(getMode() == Mode::Random);
 
-			{
-				auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-				_randomArtists = Artist::find(LmsApp->getDbSession(), params);
-			}
-		}
+        if (!_randomArtists)
+        {
+            Artist::FindParameters params;
+            params.setClusters(getFilters().getClusterIds());
+            params.setLinkType(_linkType);
+            params.setSortMethod(ArtistSortMethod::Random);
+            params.setRange(Range{ 0, getMaxCount() });
 
-		return _randomArtists->getSubRange(range);
-	}
+            {
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                _randomArtists = Artist::findIds(LmsApp->getDbSession(), params);
+            }
+        }
+
+        return _randomArtists->getSubRange(range);
+    }
 } // ns UserInterface
-
diff --git a/src/lms/ui/explore/ArtistView.cpp b/src/lms/ui/explore/ArtistView.cpp
index d90dbc5e..8410ee68 100644
--- a/src/lms/ui/explore/ArtistView.cpp
+++ b/src/lms/ui/explore/ArtistView.cpp
@@ -28,7 +28,7 @@
 #include "services/database/Session.hpp"
 #include "services/database/Track.hpp"
 #include "services/database/User.hpp"
-#include "services/scrobbling/IScrobblingService.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "services/recommendation/IRecommendationService.hpp"
 #include "utils/Logger.hpp"
 #include "utils/String.hpp"
@@ -46,342 +46,334 @@
 
 using namespace Database;
 
-namespace UserInterface {
-
-bool
-Artist::ReleaseType::operator<(const ReleaseType& other) const
+namespace UserInterface
 {
-	if (!primaryType && other.primaryType)
-		return false;
-	else if (primaryType && !other.primaryType)
-		return true;
-	else if (*primaryType == *other.primaryType)
-		return secondaryTypes.getBitfield() < other.secondaryTypes.getBitfield();
-	else
-		return static_cast<int>(*primaryType) < static_cast<int>(*other.primaryType);
-}
+    namespace
+    {
+        std::optional<ArtistId> extractArtistIdFromInternalPath()
+        {
+            if (wApp->internalPathMatches("/artist/mbid/"))
+            {
+                const auto mbid{ UUID::fromString(wApp->internalPathNextPart("/artist/mbid/")) };
+                if (mbid)
+                {
+                    auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                    if (const Database::Artist::pointer artist{ Database::Artist::find(LmsApp->getDbSession(), *mbid) })
+                        return artist->getId();
+                }
 
-Artist::Artist(Filters& filters, PlayQueueController& controller)
-: Template {Wt::WString::tr("Lms.Explore.Artist.template")}
-, _filters {filters}
-, _playQueueController {controller}
-{
-	addFunction("tr", &Wt::WTemplate::Functions::tr);
-	addFunction("id", &Wt::WTemplate::Functions::id);
+                return std::nullopt;
+            }
 
-	LmsApp->internalPathChanged().connect(this, [this]
-	{
-		refreshView();
-	});
+            return StringUtils::readAs<ArtistId::ValueType>(wApp->internalPathNextPart("/artist/"));
+        }
+    }
 
-	filters.updated().connect([this]
-	{
-		_needForceRefresh = true;
-		refreshView();
-	});
+    bool Artist::ReleaseType::operator<(const ReleaseType& other) const
+    {
+        if (!primaryType && other.primaryType)
+            return false;
+        else if (primaryType && !other.primaryType)
+            return true;
+        else if (*primaryType == *other.primaryType)
+            return secondaryTypes.getBitfield() < other.secondaryTypes.getBitfield();
+        else
+            return static_cast<int>(*primaryType) < static_cast<int>(*other.primaryType);
+    }
 
-	refreshView();
-}
+    Artist::Artist(Filters& filters, PlayQueueController& controller)
+        : Template{ Wt::WString::tr("Lms.Explore.Artist.template") }
+        , _filters{ filters }
+        , _playQueueController{ controller }
+    {
+        addFunction("tr", &Wt::WTemplate::Functions::tr);
+        addFunction("id", &Wt::WTemplate::Functions::id);
 
-static
-std::optional<ArtistId>
-extractArtistIdFromInternalPath()
-{
-	if (wApp->internalPathMatches("/artist/mbid/"))
-	{
-		const auto mbid {UUID::fromString(wApp->internalPathNextPart("/artist/mbid/"))};
-		if (mbid)
-		{
-			auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-			if (const Database::Artist::pointer artist {Database::Artist::find(LmsApp->getDbSession(), *mbid)})
-				return artist->getId();
-		}
+        LmsApp->internalPathChanged().connect(this, [this]
+            {
+                refreshView();
+            });
 
-		return std::nullopt;
-	}
+        filters.updated().connect([this]
+            {
+                _needForceRefresh = true;
+                refreshView();
+            });
 
-	return StringUtils::readAs<ArtistId::ValueType>(wApp->internalPathNextPart("/artist/"));
-}
+        refreshView();
+    }
 
-void
-Artist::refreshView()
-{
-	if (!wApp->internalPathMatches("/artist/"))
-		return;
+    void Artist::refreshView()
+    {
+        if (!wApp->internalPathMatches("/artist/"))
+            return;
 
-	const auto artistId {extractArtistIdFromInternalPath()};
+        const auto artistId{ extractArtistIdFromInternalPath() };
 
-	// consider everything is up to date is the same artist is being rendered
-	if (!_needForceRefresh && artistId && *artistId == _artistId)
-		return;
+        // consider everything is up to date is the same artist is being rendered
+        if (!_needForceRefresh && artistId && *artistId == _artistId)
+            return;
 
-	clear();
-	_artistId = {};
-	_trackContainer = nullptr;
-	_needForceRefresh = false;
+        clear();
+        _artistId = {};
+        _trackContainer = nullptr;
+        _needForceRefresh = false;
 
-	if (!artistId)
-		throw ArtistNotFoundException {};
+        if (!artistId)
+            throw ArtistNotFoundException{};
 
-	const auto similarArtistIds {Service<Recommendation::IRecommendationService>::get()->getSimilarArtists(*artistId, {TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist}, 5)};
+        const auto similarArtistIds{ Service<Recommendation::IRecommendationService>::get()->getSimilarArtists(*artistId, {TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist}, 5) };
 
-    auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-	const Database::Artist::pointer artist {Database::Artist::find(LmsApp->getDbSession(), *artistId)};
-	if (!artist)
-		throw ArtistNotFoundException {};
+        const Database::Artist::pointer artist{ Database::Artist::find(LmsApp->getDbSession(), *artistId) };
+        if (!artist)
+            throw ArtistNotFoundException{};
 
-	LmsApp->setTitle(artist->getName());
-	_artistId = *artistId;
+        LmsApp->setTitle(artist->getName());
+        _artistId = *artistId;
 
-	refreshReleases();
-	refreshAppearsOnReleases();
-	refreshNonReleaseTracks();
-	refreshLinks(artist);
-	refreshSimilarArtists(similarArtistIds);
+        refreshReleases();
+        refreshAppearsOnReleases();
+        refreshNonReleaseTracks();
+        refreshLinks(artist);
+        refreshSimilarArtists(similarArtistIds);
 
-	Wt::WContainerWidget* clusterContainers {bindNew<Wt::WContainerWidget>("clusters")};
+        Wt::WContainerWidget* clusterContainers{ bindNew<Wt::WContainerWidget>("clusters") };
 
-	{
-		auto clusterTypes = ScanSettings::get(LmsApp->getDbSession())->getClusterTypes();
-		auto clusterGroups = artist->getClusterGroups(clusterTypes, 3);
+        {
+            auto clusterTypes = ScanSettings::get(LmsApp->getDbSession())->getClusterTypes();
+            auto clusterGroups = artist->getClusterGroups(clusterTypes, 3);
 
-		for (auto clusters : clusterGroups)
-		{
-			for (const Database::Cluster::pointer& cluster : clusters)
-			{
-				const Database::ClusterId clusterId = cluster->getId();
-				Wt::WInteractWidget* entry {clusterContainers->addWidget(Utils::createCluster(clusterId))};
-				entry->clicked().connect([=]
-				{
-					_filters.add(clusterId);
-				});
-			}
-		}
-	}
+            for (auto clusters : clusterGroups)
+            {
+                for (const Database::Cluster::pointer& cluster : clusters)
+                {
+                    const Database::ClusterId clusterId = cluster->getId();
+                    Wt::WInteractWidget* entry{ clusterContainers->addWidget(Utils::createCluster(clusterId)) };
+                    entry->clicked().connect([=]
+                        {
+                            _filters.add(clusterId);
+                        });
+                }
+            }
+        }
 
-	bindString("name", Wt::WString::fromUTF8(artist->getName()), Wt::TextFormat::Plain);
+        bindString("name", Wt::WString::fromUTF8(artist->getName()), Wt::TextFormat::Plain);
 
-	bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML)
-		->clicked().connect([=]
-		{
-			_playQueueController.processCommand(PlayQueueController::Command::Play, {_artistId});
-		});
+        bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML)
+            ->clicked().connect([=]
+                {
+                    _playQueueController.processCommand(PlayQueueController::Command::Play, { _artistId });
+                });
 
-	bindNew<Wt::WPushButton>("play-shuffled", Wt::WString::tr("Lms.Explore.play-shuffled"), Wt::TextFormat::Plain)
-		->clicked().connect([=]
-		{
-			_playQueueController.processCommand(PlayQueueController::Command::PlayShuffled, {_artistId});
-		});
-	bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"), Wt::TextFormat::Plain)
-		->clicked().connect([=]
-		{
-			_playQueueController.processCommand(PlayQueueController::Command::PlayNext, {_artistId});
-		});
-	bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"), Wt::TextFormat::Plain)
-		->clicked().connect([=]
-		{
-			_playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, {_artistId});
-		});
-	bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
-		->setLink(Wt::WLink {std::make_unique<DownloadArtistResource>(_artistId)});
+        bindNew<Wt::WPushButton>("play-shuffled", Wt::WString::tr("Lms.Explore.play-shuffled"), Wt::TextFormat::Plain)
+            ->clicked().connect([=]
+                {
+                    _playQueueController.processCommand(PlayQueueController::Command::PlayShuffled, { _artistId });
+                });
+        bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"), Wt::TextFormat::Plain)
+            ->clicked().connect([=]
+                {
+                    _playQueueController.processCommand(PlayQueueController::Command::PlayNext, { _artistId });
+                });
+        bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"), Wt::TextFormat::Plain)
+            ->clicked().connect([=]
+                {
+                    _playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, { _artistId });
+                });
+        bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
+            ->setLink(Wt::WLink{ std::make_unique<DownloadArtistResource>(_artistId) });
 
-	{
-		auto isStarred {[=] { return Service<Scrobbling::IScrobblingService>::get()->isStarred(LmsApp->getUserId(), _artistId); }};
+        {
+            auto isStarred{ [=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), _artistId); } };
 
-		Wt::WPushButton* starBtn {bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star"))};
-		starBtn->clicked().connect([=]
-		{
-			if (isStarred())
-			{
-				Service<Scrobbling::IScrobblingService>::get()->unstar(LmsApp->getUserId(), _artistId);
-				starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
-			}
-			else
-			{
-				Service<Scrobbling::IScrobblingService>::get()->star(LmsApp->getUserId(), _artistId);
-				starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
-			}
-		});
-	}
-}
+            Wt::WPushButton* starBtn{ bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star")) };
+            starBtn->clicked().connect([=]
+                {
+                    if (isStarred())
+                    {
+                        Service<Feedback::IFeedbackService>::get()->unstar(LmsApp->getUserId(), _artistId);
+                        starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
+                    }
+                    else
+                    {
+                        Service<Feedback::IFeedbackService>::get()->star(LmsApp->getUserId(), _artistId);
+                        starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
+                    }
+                });
+        }
+    }
 
-void
-Artist::refreshReleases()
-{
-	_releaseContainers.clear();
+    void Artist::refreshReleases()
+    {
+        _releaseContainers.clear();
 
-	Release::FindParameters params;
-	params.setClusters(_filters.getClusterIds());
-	params.setArtist(_artistId, {TrackArtistLinkType::ReleaseArtist}, {});
-	params.setSortMethod(ReleaseSortMethod::OriginalDateDesc);
+        Release::FindParameters params;
+        params.setClusters(_filters.getClusterIds());
+        params.setArtist(_artistId, { TrackArtistLinkType::ReleaseArtist }, {});
+        params.setSortMethod(ReleaseSortMethod::OriginalDateDesc);
 
-	const auto releases {Release::find(LmsApp->getDbSession(), params)};
-	if (!releases.results.empty())
-	{
-		// first pass: gather all ids and sort by type
-		for (const ReleaseId releaseId : releases.results)
-		{
-			const Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), releaseId)};
+        const auto releases{ Release::findIds(LmsApp->getDbSession(), params) };
+        if (!releases.results.empty())
+        {
+            // first pass: gather all ids and sort by type
+            for (const ReleaseId releaseId : releases.results)
+            {
+                const Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), releaseId) };
 
-			ReleaseType releaseType {release->getPrimaryType(), release->getSecondaryTypes()};
-			_releaseContainers[releaseType].releases.push_back(releaseId);
-		}
+                ReleaseType releaseType{ release->getPrimaryType(), release->getSecondaryTypes() };
+                _releaseContainers[releaseType].releases.push_back(releaseId);
+            }
 
-		// second pass: construct widgets
-		Wt::WContainerWidget* releaseContainers {bindNew<Wt::WContainerWidget>("release-containers")};
-		for (auto& [releaseType, releases] : _releaseContainers)
-		{
-			Wt::WTemplate* releaseContainer {releaseContainers->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Artist.template.release-container"))};
+            // second pass: construct widgets
+            Wt::WContainerWidget* releaseContainers{ bindNew<Wt::WContainerWidget>("release-containers") };
+            for (auto& [releaseType, releases] : _releaseContainers)
+            {
+                Wt::WTemplate* releaseContainer{ releaseContainers->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Artist.template.release-container")) };
 
-			if (releaseType.primaryType)
-				releaseContainer->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(*releaseType.primaryType, releaseType.secondaryTypes));
-			else
-				releaseContainer->bindString("release-type", Wt::WString::tr("Lms.Explore.releases")); // fallback when not tagged with MB
+                if (releaseType.primaryType)
+                    releaseContainer->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(*releaseType.primaryType, releaseType.secondaryTypes));
+                else
+                    releaseContainer->bindString("release-type", Wt::WString::tr("Lms.Explore.releases")); // fallback when not tagged with MB
 
-			releases.container = releaseContainer->bindNew<InfiniteScrollingContainer>("releases", Wt::WString::tr("Lms.Explore.Releases.template.container"));
-			releases.container->onRequestElements.connect(this, [this, &releases = releases]
-			{
-				addSomeReleases(releases);
-			});
-		}
-	}
-	else
-	{
-		bindEmpty("release-containers");
-	}
-}
+                releases.container = releaseContainer->bindNew<InfiniteScrollingContainer>("releases", Wt::WString::tr("Lms.Explore.Releases.template.container"));
+                releases.container->onRequestElements.connect(this, [this, &releases = releases]
+                    {
+                        addSomeReleases(releases);
+                    });
+            }
+        }
+        else
+        {
+            bindEmpty("release-containers");
+        }
+    }
 
-void
-Artist::refreshAppearsOnReleases()
-{
-	constexpr EnumSet<TrackArtistLinkType> types
-	{
-		TrackArtistLinkType::Artist,
-		TrackArtistLinkType::Arranger,
-		TrackArtistLinkType::Composer,
-		TrackArtistLinkType::Conductor,
-		TrackArtistLinkType::Lyricist,
-		TrackArtistLinkType::Mixer,
-		TrackArtistLinkType::Performer,
-		TrackArtistLinkType::Producer,
-		TrackArtistLinkType::Remixer,
-		TrackArtistLinkType::Writer,
-	};
+    void Artist::refreshAppearsOnReleases()
+    {
+        constexpr EnumSet<TrackArtistLinkType> types
+        {
+            TrackArtistLinkType::Artist,
+            TrackArtistLinkType::Arranger,
+            TrackArtistLinkType::Composer,
+            TrackArtistLinkType::Conductor,
+            TrackArtistLinkType::Lyricist,
+            TrackArtistLinkType::Mixer,
+            TrackArtistLinkType::Performer,
+            TrackArtistLinkType::Producer,
+            TrackArtistLinkType::Remixer,
+            TrackArtistLinkType::Writer,
+        };
 
-	_appearsOnReleaseContainer = {};
+        _appearsOnReleaseContainer = {};
 
-	Release::FindParameters params;
-	params.setClusters(_filters.getClusterIds());
-	params.setArtist(_artistId, types, {TrackArtistLinkType::ReleaseArtist});
-	params.setSortMethod(ReleaseSortMethod::OriginalDateDesc);
+        Release::FindParameters params;
+        params.setClusters(_filters.getClusterIds());
+        params.setArtist(_artistId, types, { TrackArtistLinkType::ReleaseArtist });
+        params.setSortMethod(ReleaseSortMethod::OriginalDateDesc);
 
-	const auto releases {Release::find(LmsApp->getDbSession(), params)};
-	if (!releases.results.empty())
-	{
-		Wt::WTemplate* releaseContainer  {bindNew<Wt::WTemplate>("appears-on-releases", Wt::WString::tr("Lms.Explore.Artist.template.release-container"))};
-		releaseContainer->bindString("release-type", Wt::WString::tr("Lms.Explore.Artist.appears-on"));
-		_appearsOnReleaseContainer.releases = releases.results;
-		_appearsOnReleaseContainer.container = releaseContainer->bindNew<InfiniteScrollingContainer>("releases", Wt::WString::tr("Lms.Explore.Releases.template.container"));
-		_appearsOnReleaseContainer.container->onRequestElements.connect(this, [this]
-		{
-			addSomeReleases(_appearsOnReleaseContainer);
-		});
-	}
-	else
-	{
-		bindEmpty("appears-on-releases");
-	}
-}
+        const auto releases{ Release::findIds(LmsApp->getDbSession(), params) };
+        if (!releases.results.empty())
+        {
+            Wt::WTemplate* releaseContainer{ bindNew<Wt::WTemplate>("appears-on-releases", Wt::WString::tr("Lms.Explore.Artist.template.release-container")) };
+            releaseContainer->bindString("release-type", Wt::WString::tr("Lms.Explore.Artist.appears-on"));
+            _appearsOnReleaseContainer.releases = releases.results;
+            _appearsOnReleaseContainer.container = releaseContainer->bindNew<InfiniteScrollingContainer>("releases", Wt::WString::tr("Lms.Explore.Releases.template.container"));
+            _appearsOnReleaseContainer.container->onRequestElements.connect(this, [this]
+                {
+                    addSomeReleases(_appearsOnReleaseContainer);
+                });
+        }
+        else
+        {
+            bindEmpty("appears-on-releases");
+        }
+    }
 
-void
-Artist::refreshNonReleaseTracks()
-{
-	setCondition("if-has-non-release-tracks", true);
-	_trackContainer = bindNew<InfiniteScrollingContainer>("tracks");
-	_trackContainer->onRequestElements.connect(this, [this]
-	{
-		addSomeNonReleaseTracks();
-	});
+    void Artist::refreshNonReleaseTracks()
+    {
+        setCondition("if-has-non-release-tracks", true);
+        _trackContainer = bindNew<InfiniteScrollingContainer>("tracks");
+        _trackContainer->onRequestElements.connect(this, [this]
+            {
+                addSomeNonReleaseTracks();
+            });
 
-	const bool added {addSomeNonReleaseTracks()};
-	setCondition("if-has-non-release-tracks", added);
-}
+        const bool added{ addSomeNonReleaseTracks() };
+        setCondition("if-has-non-release-tracks", added);
+    }
 
-void
-Artist::refreshSimilarArtists(const std::vector<ArtistId>& similarArtistsId)
-{
-	if (similarArtistsId.empty())
-		return;
+    void Artist::refreshSimilarArtists(const std::vector<ArtistId>& similarArtistsId)
+    {
+        if (similarArtistsId.empty())
+            return;
 
-	setCondition("if-has-similar-artists", true);
-	Wt::WContainerWidget* similarArtistsContainer {bindNew<Wt::WContainerWidget>("similar-artists")};
+        setCondition("if-has-similar-artists", true);
+        Wt::WContainerWidget* similarArtistsContainer{ bindNew<Wt::WContainerWidget>("similar-artists") };
 
-	for (const ArtistId artistId : similarArtistsId)
-	{
-		const Database::Artist::pointer similarArtist {Database::Artist::find(LmsApp->getDbSession(), artistId)};
-		if (!similarArtist)
-			continue;
+        for (const ArtistId artistId : similarArtistsId)
+        {
+            const Database::Artist::pointer similarArtist{ Database::Artist::find(LmsApp->getDbSession(), artistId) };
+            if (!similarArtist)
+                continue;
 
-		similarArtistsContainer->addWidget(ArtistListHelpers::createEntry(similarArtist));
-	}
-}
+            similarArtistsContainer->addWidget(ArtistListHelpers::createEntry(similarArtist));
+        }
+    }
 
-void
-Artist::refreshLinks(const Database::Artist::pointer& artist)
-{
-	const auto mbid {artist->getMBID()};
-	if (mbid)
-	{
-		setCondition("if-has-mbid", true);
-		bindString("mbid-link", std::string {"https://musicbrainz.org/artist/"} + std::string {mbid->getAsString()});
-	}
-}
+    void Artist::refreshLinks(const Database::Artist::pointer& artist)
+    {
+        const auto mbid{ artist->getMBID() };
+        if (mbid)
+        {
+            setCondition("if-has-mbid", true);
+            bindString("mbid-link", std::string{ "https://musicbrainz.org/artist/" } + std::string{ mbid->getAsString() });
+        }
+    }
 
-void
-Artist::addSomeReleases(ReleaseContainer& releaseContainer)
-{
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+    void Artist::addSomeReleases(ReleaseContainer& releaseContainer)
+    {
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-	if (const Database::Artist::pointer artist {Database::Artist::find(LmsApp->getDbSession(), _artistId)})
-	{
-		for (std::size_t i {static_cast<std::size_t>(releaseContainer.container->getCount())}; i < releaseContainer.releases.size(); ++i)
-		{
-			const Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), releaseContainer.releases[i])};
-			releaseContainer.container->add(ReleaseListHelpers::createEntryForArtist(release, artist));
-		}
-	}
-}
+        if (const Database::Artist::pointer artist{ Database::Artist::find(LmsApp->getDbSession(), _artistId) })
+        {
+            for (std::size_t i{ static_cast<std::size_t>(releaseContainer.container->getCount()) }; i < releaseContainer.releases.size(); ++i)
+            {
+                const Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), releaseContainer.releases[i]) };
+                releaseContainer.container->add(ReleaseListHelpers::createEntryForArtist(release, artist));
+            }
+        }
+    }
 
-bool
-Artist::addSomeNonReleaseTracks()
-{
-	bool areTracksAdded{};
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+    bool Artist::addSomeNonReleaseTracks()
+    {
+        bool areTracksAdded{};
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-	const Range range {static_cast<std::size_t>(_trackContainer->getCount()), _tracksBatchSize};
+        const Range range{ static_cast<std::size_t>(_trackContainer->getCount()), _tracksBatchSize };
 
-	Track::FindParameters params;
-	params.setClusters(_filters.getClusterIds());
-	params.setArtist(_artistId);
-	params.setRange(range);
-	params.setSortMethod(TrackSortMethod::Name);
-	params.setNonRelease(true);
+        Track::FindParameters params;
+        params.setClusters(_filters.getClusterIds());
+        params.setArtist(_artistId);
+        params.setRange(range);
+        params.setSortMethod(TrackSortMethod::Name);
+        params.setNonRelease(true);
 
-	const auto tracks {Track::find(LmsApp->getDbSession(), params)};
-	for (const TrackId trackId : tracks.results)
-	{
-		if (_trackContainer->getCount() == _tracksMaxCount)
-			break;
+        const auto tracks{ Track::find(LmsApp->getDbSession(), params) };
+        for (const Track::pointer& track : tracks.results)
+        {
+            // TODO handle this with range
+            if (_trackContainer->getCount() == _tracksMaxCount)
+                break;
 
-		const Track::pointer track {Track::find(LmsApp->getDbSession(), trackId)};
-		_trackContainer->add(TrackListHelpers::createEntry(track, _playQueueController, _filters));
+            _trackContainer->add(TrackListHelpers::createEntry(track, _playQueueController, _filters));
 
-		areTracksAdded = true;
-	}
+            areTracksAdded = true;
+        }
 
-	return areTracksAdded;
-}
+        return areTracksAdded;
+    }
 
 } // namespace UserInterface
 
diff --git a/src/lms/ui/explore/DatabaseCollectorBase.cpp b/src/lms/ui/explore/DatabaseCollectorBase.cpp
index 7a161fd7..16afcc7f 100644
--- a/src/lms/ui/explore/DatabaseCollectorBase.cpp
+++ b/src/lms/ui/explore/DatabaseCollectorBase.cpp
@@ -23,34 +23,35 @@
 
 namespace UserInterface
 {
-	DatabaseCollectorBase::DatabaseCollectorBase(Filters& filters, Mode defaultMode, std::size_t maxCount)
-		: _filters {filters}
-		, _mode {defaultMode}
-		, _maxCount {maxCount}
-	{
-	}
+    DatabaseCollectorBase::DatabaseCollectorBase(Filters& filters, Mode defaultMode, std::size_t maxCount)
+        : _filters{ filters }
+        , _mode{ defaultMode }
+        , _maxCount{ maxCount }
+    {
+    }
 
-	DatabaseCollectorBase::Range
-	DatabaseCollectorBase::getActualRange(Range range) const
-	{
-		assert(range.offset < _maxCount);
-		range.size = std::min(_maxCount - range.offset, range.size);
+    DatabaseCollectorBase::Range DatabaseCollectorBase::getActualRange(Range range) const
+    {
+        assert(range.size > 0);
 
-		return range;
-	}
+        if (range.offset < _maxCount)
+            range.size = std::min(_maxCount - range.offset, range.size);
+        else
+            range.size = 0;
 
-	std::size_t
-	DatabaseCollectorBase::getMaxCount() const
-	{
-		return _maxCount;
-	}
+        return range;
+    }
 
-	void
-	DatabaseCollectorBase::setSearch(std::string_view searchText)
-	{
-		_searchText = searchText;
-		_searchKeywords = StringUtils::splitString(_searchText, " ");
-	}
+    std::size_t DatabaseCollectorBase::getMaxCount() const
+    {
+        return _maxCount;
+    }
+
+    void DatabaseCollectorBase::setSearch(std::string_view searchText)
+    {
+        _searchText = searchText;
+        _searchKeywords = StringUtils::splitString(_searchText, " ");
+    }
 
 } // ns UserInterface
 
diff --git a/src/lms/ui/explore/DatabaseCollectorBase.hpp b/src/lms/ui/explore/DatabaseCollectorBase.hpp
index 66732c32..2d654779 100644
--- a/src/lms/ui/explore/DatabaseCollectorBase.hpp
+++ b/src/lms/ui/explore/DatabaseCollectorBase.hpp
@@ -29,44 +29,43 @@
 
 namespace UserInterface
 {
-	class Filters;
+    class Filters;
 
-	class DatabaseCollectorBase
-	{
-		public:
-			using Range = Database::Range;
+    class DatabaseCollectorBase
+    {
+    public:
+        using Range = Database::Range;
 
-			virtual ~DatabaseCollectorBase() {}
+        virtual ~DatabaseCollectorBase() {}
 
-			enum class Mode
-			{
-				Random,
-				Starred,
-				RecentlyPlayed,
-				RecentlyAdded,
-				MostPlayed,
-				Search,
-				All
-			};
+        enum class Mode
+        {
+            Random,
+            Starred,
+            RecentlyPlayed,
+            RecentlyAdded,
+            MostPlayed,
+            Search,
+            All
+        };
 
-			DatabaseCollectorBase(Filters& filters, Mode defaultMode, std::size_t maxCount);
+        DatabaseCollectorBase(Filters& filters, Mode defaultMode, std::size_t maxCount);
 
-			Mode getMode() const { return _mode; }
-			void setMode(Mode mode) { _mode = mode; }
-			void setSearch(std::string_view search);
+        Mode getMode() const { return _mode; }
+        void setMode(Mode mode) { _mode = mode; }
+        void setSearch(std::string_view search);
 
-		protected:
-			Range		getActualRange(Range range) const;
-			std::size_t	getMaxCount() const;
-			Filters&	getFilters() { return _filters; }
-			const std::vector<std::string_view>& getSearchKeywords() const { return _searchKeywords; }
+    protected:
+        Range       getActualRange(Range range) const;
+        std::size_t getMaxCount() const;
+        Filters& getFilters() { return _filters; }
+        const std::vector<std::string_view>& getSearchKeywords() const { return _searchKeywords; }
 
-		private:
-			Filters&	_filters;
-			std::string	_searchText;
-			std::vector<std::string_view> _searchKeywords;
-			Mode		_mode;
-			std::size_t _maxCount;
-	};
+    private:
+        Filters& _filters;
+        std::string _searchText;
+        std::vector<std::string_view> _searchKeywords;
+        Mode        _mode;
+        std::size_t _maxCount;
+    };
 } // ns UserInterface
-
diff --git a/src/lms/ui/explore/PlayQueueController.cpp b/src/lms/ui/explore/PlayQueueController.cpp
index f34cc8e9..0329b880 100644
--- a/src/lms/ui/explore/PlayQueueController.cpp
+++ b/src/lms/ui/explore/PlayQueueController.cpp
@@ -29,153 +29,145 @@
 namespace UserInterface
 {
 
-	static
-	std::vector<Database::TrackId>
-	getArtistsTracks(Database::Session& session, const std::vector<Database::ArtistId>& artistsId, const std::vector<Database::ClusterId>& clusters, std::size_t maxTrackCount)
-	{
-		assert(maxTrackCount);
+    namespace
+    {
+        std::vector<Database::TrackId> getArtistsTracks(Database::Session& session, const std::vector<Database::ArtistId>& artistsId, const std::vector<Database::ClusterId>& clusters, std::size_t maxTrackCount)
+        {
+            assert(maxTrackCount);
 
-		std::vector<Database::TrackId> res;
+            std::vector<Database::TrackId> res;
 
-		auto transaction {session.createSharedTransaction()};
+            auto transaction{ session.createSharedTransaction() };
 
-		for (const Database::ArtistId artistId : artistsId)
-		{
-			Database::Track::FindParameters params;
-			params.setArtist(artistId);
-			params.setSortMethod(Database::TrackSortMethod::DateDescAndRelease);
-			params.setClusters(clusters);
-			params.setRange({0, maxTrackCount - res.size()});
+            for (const Database::ArtistId artistId : artistsId)
+            {
+                Database::Track::FindParameters params;
+                params.setArtist(artistId);
+                params.setSortMethod(Database::TrackSortMethod::DateDescAndRelease);
+                params.setClusters(clusters);
+                params.setRange({ 0, maxTrackCount - res.size() });
 
-			const auto tracks {Database::Track::find(session, params)};
+                const auto tracks{ Database::Track::findIds(session, params) };
 
-			res.reserve(res.size() + tracks.results.size());
-			res.insert(std::end(res), std::cbegin(tracks.results), std::cend(tracks.results));
+                res.reserve(res.size() + tracks.results.size());
+                res.insert(std::end(res), std::cbegin(tracks.results), std::cend(tracks.results));
 
-			if (res.size() == maxTrackCount)
-				break;
-		}
+                if (res.size() == maxTrackCount)
+                    break;
+            }
 
-		return res;
-	}
+            return res;
+        }
 
-	static
-	std::vector<Database::TrackId>
-	getReleasesTracks(Database::Session& session, const std::vector<Database::ReleaseId>& releasesId, const std::vector<Database::ClusterId>& clusters, std::size_t maxTrackCount)
-	{
-		using namespace Database;
-		assert(maxTrackCount);
+        std::vector<Database::TrackId> getReleasesTracks(Database::Session& session, const std::vector<Database::ReleaseId>& releasesId, const std::vector<Database::ClusterId>& clusters, std::size_t maxTrackCount)
+        {
+            using namespace Database;
+            assert(maxTrackCount);
 
-		std::vector<TrackId> res;
+            std::vector<TrackId> res;
 
-		auto transaction {session.createSharedTransaction()};
+            auto transaction{ session.createSharedTransaction() };
 
-		for (const ReleaseId releaseId : releasesId)
-		{
-			Database::Track::FindParameters params;
-			params.setRelease(releaseId);
-			params.setSortMethod(Database::TrackSortMethod::Release);
-			params.setClusters(clusters);
-			params.setRange({0, maxTrackCount - res.size()});
+            for (const ReleaseId releaseId : releasesId)
+            {
+                Database::Track::FindParameters params;
+                params.setRelease(releaseId);
+                params.setSortMethod(Database::TrackSortMethod::Release);
+                params.setClusters(clusters);
+                params.setRange({ 0, maxTrackCount - res.size() });
 
-			const auto tracks {Database::Track::find(session, params)};
+                const auto tracks{ Database::Track::findIds(session, params) };
 
-			res.reserve(res.size() + tracks.results.size());
-			res.insert(std::end(res), std::cbegin(tracks.results), std::cend(tracks.results));
+                res.reserve(res.size() + tracks.results.size());
+                res.insert(std::end(res), std::cbegin(tracks.results), std::cend(tracks.results));
 
-			if (res.size() == maxTrackCount)
-				break;
-		}
+                if (res.size() == maxTrackCount)
+                    break;
+            }
 
-		return res;
-	}
+            return res;
+        }
 
-	static
-	std::vector<Database::TrackId>
-	getTrackListTracks(Database::Session& session, Database::TrackListId trackListId, const std::vector<Database::ClusterId>& clusters, std::size_t maxTrackCount)
-	{
-		using namespace Database;
-		assert(maxTrackCount);
+        std::vector<Database::TrackId> getTrackListTracks(Database::Session& session, Database::TrackListId trackListId, const std::vector<Database::ClusterId>& clusters, std::size_t maxTrackCount)
+        {
+            using namespace Database;
+            assert(maxTrackCount);
 
-		auto transaction {session.createSharedTransaction()};
+            auto transaction{ session.createSharedTransaction() };
 
-		Database::Track::FindParameters params;
-		params.setTrackList(trackListId);
-		params.setClusters(clusters);
-		params.setRange({0, maxTrackCount});
-		params.setSortMethod(TrackSortMethod::TrackList);
-		params.setDistinct(false);
+            Database::Track::FindParameters params;
+            params.setTrackList(trackListId);
+            params.setClusters(clusters);
+            params.setRange({ 0, maxTrackCount });
+            params.setSortMethod(TrackSortMethod::TrackList);
+            params.setDistinct(false);
 
-		return Database::Track::find(session, params).results;
-	}
+            return Database::Track::findIds(session, params).results;
+        }
+    }
 
-	PlayQueueController::PlayQueueController(Filters& filters, PlayQueue& playQueue)
-		: _filters {filters}
-	, _playQueue {playQueue}
-	{
-	}
+    PlayQueueController::PlayQueueController(Filters& filters, PlayQueue& playQueue)
+        : _filters{ filters }
+        , _playQueue{ playQueue }
+    {
+    }
 
-	void
-	PlayQueueController::processCommand(Command command, const std::vector<Database::ArtistId>& artistIds)
-	{
-		const std::vector<Database::TrackId> tracks {getArtistsTracks(LmsApp->getDbSession(), artistIds, _filters.getClusterIds(), _maxTrackCountToEnqueue)};
-		processCommand(command, tracks);
-	}
+    void PlayQueueController::processCommand(Command command, const std::vector<Database::ArtistId>& artistIds)
+    {
+        const std::vector<Database::TrackId> tracks{ getArtistsTracks(LmsApp->getDbSession(), artistIds, _filters.getClusterIds(), _maxTrackCountToEnqueue) };
+        processCommand(command, tracks);
+    }
 
-	void
-	PlayQueueController::processCommand(Command command, const std::vector<Database::ReleaseId>& releaseIds)
-	{
-		const std::vector<Database::TrackId> tracks {getReleasesTracks(LmsApp->getDbSession(), releaseIds, _filters.getClusterIds(), _maxTrackCountToEnqueue)};
-		processCommand(command, tracks);
-	}
+    void PlayQueueController::processCommand(Command command, const std::vector<Database::ReleaseId>& releaseIds)
+    {
+        const std::vector<Database::TrackId> tracks{ getReleasesTracks(LmsApp->getDbSession(), releaseIds, _filters.getClusterIds(), _maxTrackCountToEnqueue) };
+        processCommand(command, tracks);
+    }
 
-	void
-	PlayQueueController::processCommand(Command command, const std::vector<Database::TrackId>& trackIds)
-	{
-		// consider things are already filtered here, and _maxTrackCount honored playqueue side...
-		switch (command)
-		{
-			case Command::Play:
-				_playQueue.play(trackIds);
-				break;
-			case Command::PlayNext:
-				_playQueue.playNext(trackIds);
-				break;
-			case Command::PlayShuffled:
-				_playQueue.playShuffled(trackIds);
-				break;
-			case Command::PlayOrAddLast:
-				_playQueue.playOrAddLast(trackIds);
-			break;
-		}
-	}
+    void PlayQueueController::processCommand(Command command, const std::vector<Database::TrackId>& trackIds)
+    {
+        // consider things are already filtered here, and _maxTrackCount honored playqueue side...
+        switch (command)
+        {
+        case Command::Play:
+            _playQueue.play(trackIds);
+            break;
+        case Command::PlayNext:
+            _playQueue.playNext(trackIds);
+            break;
+        case Command::PlayShuffled:
+            _playQueue.playShuffled(trackIds);
+            break;
+        case Command::PlayOrAddLast:
+            _playQueue.playOrAddLast(trackIds);
+            break;
+        }
+    }
 
-	void
-	PlayQueueController::processCommand(Command command, Database::TrackListId trackListId)
-	{
-		const std::vector<Database::TrackId> tracks {getTrackListTracks(LmsApp->getDbSession(), trackListId, _filters.getClusterIds(), _maxTrackCountToEnqueue)};
-		processCommand(command, tracks);
-	}
+    void PlayQueueController::processCommand(Command command, Database::TrackListId trackListId)
+    {
+        const std::vector<Database::TrackId> tracks{ getTrackListTracks(LmsApp->getDbSession(), trackListId, _filters.getClusterIds(), _maxTrackCountToEnqueue) };
+        processCommand(command, tracks);
+    }
 
-	void
-	PlayQueueController::playTrackInRelease(Database::TrackId trackId)
-	{
-		Database::ReleaseId releaseId;
-		{
-			auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-			const Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), trackId)};
-			if (!track || !track->getRelease())
-				return;
+    void PlayQueueController::playTrackInRelease(Database::TrackId trackId)
+    {
+        Database::ReleaseId releaseId;
+        {
+            auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+            const Database::Track::pointer track{ Database::Track::find(LmsApp->getDbSession(), trackId) };
+            if (!track || !track->getRelease())
+                return;
 
-			releaseId = track->getRelease()->getId();
-		}
+            releaseId = track->getRelease()->getId();
+        }
 
-		const std::vector<Database::TrackId> tracks {getReleasesTracks(LmsApp->getDbSession(), {releaseId}, _filters.getClusterIds(), _maxTrackCountToEnqueue)};
-		auto itTrack {std::find(std::cbegin(tracks), std::cend(tracks), trackId)};
-		if (itTrack == std::cend(tracks))
-			return;
+        const std::vector<Database::TrackId> tracks{ getReleasesTracks(LmsApp->getDbSession(), {releaseId}, _filters.getClusterIds(), _maxTrackCountToEnqueue) };
+        auto itTrack{ std::find(std::cbegin(tracks), std::cend(tracks), trackId) };
+        if (itTrack == std::cend(tracks))
+            return;
 
-		const std::size_t index {static_cast<std::size_t>(std::distance(std::cbegin(tracks), itTrack))};
-		_playQueue.playAtIndex(tracks, index);
-	}
+        const std::size_t index{ static_cast<std::size_t>(std::distance(std::cbegin(tracks), itTrack)) };
+        _playQueue.playAtIndex(tracks, index);
+    }
 } // namespace UserInterface
diff --git a/src/lms/ui/explore/ReleaseCollector.cpp b/src/lms/ui/explore/ReleaseCollector.cpp
index cb91cac9..4a421d4c 100644
--- a/src/lms/ui/explore/ReleaseCollector.cpp
+++ b/src/lms/ui/explore/ReleaseCollector.cpp
@@ -19,12 +19,10 @@
 
 #include "ReleaseCollector.hpp"
 
-#include <algorithm>
-
 #include "services/database/Release.hpp"
 #include "services/database/Session.hpp"
 #include "services/database/User.hpp"
-#include "services/database/TrackList.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "services/scrobbling/IScrobblingService.hpp"
 #include "utils/Service.hpp"
 #include "Filters.hpp"
@@ -32,104 +30,104 @@
 
 namespace UserInterface
 {
-	using namespace Database;
+    using namespace Database;
 
-	RangeResults<ReleaseId>
-	ReleaseCollector::get(Database::Range range)
-	{
-		Scrobbling::IScrobblingService& scrobbling {*Service<Scrobbling::IScrobblingService>::get()};
+    RangeResults<ReleaseId> ReleaseCollector::get(Database::Range range)
+    {
+        Feedback::IFeedbackService& feedbackService{ *Service<Feedback::IFeedbackService>::get() };
+        Scrobbling::IScrobblingService& scrobblingService{ *Service<Scrobbling::IScrobblingService>::get() };
 
-		range = getActualRange(range);
+        RangeResults<ReleaseId> releases;
+        range = getActualRange(range);
+        if (range.size == 0)
+            return releases;
 
-		RangeResults<ReleaseId> releases;
-		switch (getMode())
-		{
-			case Mode::Random:
-				releases = getRandomReleases(range);
-				break;
+        switch (getMode())
+        {
+        case Mode::Random:
+            releases = getRandomReleases(range);
+            break;
 
-			case Mode::Starred:
-				releases = scrobbling.getStarredReleases(LmsApp->getUserId(), getFilters().getClusterIds(), range);
-				break;
+        case Mode::Starred:
+            releases = feedbackService.getStarredReleases(LmsApp->getUserId(), getFilters().getClusterIds(), range);
+            break;
 
-			case ReleaseCollector::Mode::RecentlyPlayed:
-				releases = scrobbling.getRecentReleases(LmsApp->getUserId(), getFilters().getClusterIds(), range);
-				break;
+        case ReleaseCollector::Mode::RecentlyPlayed:
+            releases = scrobblingService.getRecentReleases(LmsApp->getUserId(), getFilters().getClusterIds(), range);
+            break;
 
-			case Mode::MostPlayed:
-				releases = scrobbling.getTopReleases(LmsApp->getUserId(), getFilters().getClusterIds(), range);
-				break;
+        case Mode::MostPlayed:
+            releases = scrobblingService.getTopReleases(LmsApp->getUserId(), getFilters().getClusterIds(), range);
+            break;
 
-			case Mode::RecentlyAdded:
-			{
-				Release::FindParameters params;
-				params.setClusters(getFilters().getClusterIds());
-				params.setSortMethod(ReleaseSortMethod::LastWritten);
-				params.setRange(range);
+        case Mode::RecentlyAdded:
+        {
+            Release::FindParameters params;
+            params.setClusters(getFilters().getClusterIds());
+            params.setSortMethod(ReleaseSortMethod::LastWritten);
+            params.setRange(range);
 
-				{
-					auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-					releases = Release::find(LmsApp->getDbSession(), params);
-				}
-				break;
-			}
+            {
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                releases = Release::findIds(LmsApp->getDbSession(), params);
+            }
+            break;
+        }
 
-			case Mode::Search:
-			{
-				Release::FindParameters params;
-				params.setClusters(getFilters().getClusterIds());
-				params.setKeywords(getSearchKeywords());
-				params.setSortMethod(ReleaseSortMethod::Name);
-				params.setRange(range);
+        case Mode::Search:
+        {
+            Release::FindParameters params;
+            params.setClusters(getFilters().getClusterIds());
+            params.setKeywords(getSearchKeywords());
+            params.setRange(range);
 
-				{
-					auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-					releases = Release::find(LmsApp->getDbSession(), params);
-				}
-				break;
-			}
+            {
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                releases = Release::findIds(LmsApp->getDbSession(), params);
+            }
+            break;
+        }
 
-			case Mode::All:
-			{
-				Release::FindParameters params;
-				params.setClusters(getFilters().getClusterIds());
-				params.setSortMethod(ReleaseSortMethod::Name);
-				params.setRange(range);
+        case Mode::All:
+        {
+            Release::FindParameters params;
+            params.setClusters(getFilters().getClusterIds());
+            params.setSortMethod(ReleaseSortMethod::Name);
+            params.setRange(range);
 
-				{
-					auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-					releases = Release::find(LmsApp->getDbSession(), params);
-				}
-				break;
-			}
-		}
+            {
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                releases = Release::findIds(LmsApp->getDbSession(), params);
+            }
+            break;
+        }
+        }
 
-		if (range.offset + range.size == getMaxCount())
-			releases.moreResults = false;
+        if (range.offset + range.size == getMaxCount())
+            releases.moreResults = false;
 
-		return releases;
-	}
+        return releases;
+    }
 
-	RangeResults<ReleaseId>
-	ReleaseCollector::getRandomReleases(Range range)
-	{
-		assert(getMode() == Mode::Random);
+    RangeResults<ReleaseId> ReleaseCollector::getRandomReleases(Range range)
+    {
+        assert(getMode() == Mode::Random);
 
-		if (!_randomReleases)
-		{
-			Release::FindParameters params;
-			params.setClusters(getFilters().getClusterIds());
-			params.setSortMethod(ReleaseSortMethod::Random);
-			params.setRange({0, getMaxCount()});
+        if (!_randomReleases)
+        {
+            Release::FindParameters params;
+            params.setClusters(getFilters().getClusterIds());
+            params.setSortMethod(ReleaseSortMethod::Random);
+            params.setRange({ 0, getMaxCount() });
 
-			{
-				auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-				_randomReleases = Release::find(LmsApp->getDbSession(), params);
-			}
-		}
+            {
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                _randomReleases = Release::findIds(LmsApp->getDbSession(), params);
+            }
+        }
 
-		return _randomReleases->getSubRange(range);
-	}
+        return _randomReleases->getSubRange(range);
+    }
 
 } // ns UserInterface
 
diff --git a/src/lms/ui/explore/ReleaseView.cpp b/src/lms/ui/explore/ReleaseView.cpp
index 4b5770ee..40754fc2 100644
--- a/src/lms/ui/explore/ReleaseView.cpp
+++ b/src/lms/ui/explore/ReleaseView.cpp
@@ -32,8 +32,8 @@
 #include "services/database/Session.hpp"
 #include "services/database/Track.hpp"
 #include "services/database/TrackArtistLink.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "services/recommendation/IRecommendationService.hpp"
-#include "services/scrobbling/IScrobblingService.hpp"
 #include "utils/Logger.hpp"
 
 #include "common/Template.hpp"
@@ -50,501 +50,488 @@
 
 using namespace Database;
 
-namespace UserInterface {
-
-void
-showReleaseInfoModal(Database::ReleaseId releaseId)
+namespace UserInterface
 {
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-
-	const Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), releaseId)};
-	if (!release)
-		return;
-
-	auto releaseInfo {std::make_unique<Template>(Wt::WString::tr("Lms.Explore.Release.template.release-info"))};
-	Wt::WWidget* releaseInfoPtr {releaseInfo.get()};
-	releaseInfo->addFunction("tr", &Wt::WTemplate::Functions::tr);
-
-	if (auto primaryReleaseType {release->getPrimaryType()})
-	{
-		releaseInfo->setCondition("if-has-release-type", true);
-		releaseInfo->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(*primaryReleaseType, release->getSecondaryTypes()));
-	}
-
-	std::map<Wt::WString, std::set<ArtistId>> artistMap;
-
-	auto addArtists = [&](TrackArtistLinkType linkType, const char* type)
-	{
-		Artist::FindParameters params;
-		params.setRelease(releaseId);
-		params.setLinkType(linkType);
-		const auto artistIds {Artist::find(LmsApp->getDbSession(), params)};
-		if (artistIds.results.empty())
-			return;
-
-		Wt::WString typeStr {Wt::WString::trn(type, artistIds.results.size())};
-		for (ArtistId artistId : artistIds.results)
-			artistMap[typeStr].insert(artistId);
-	};
-
-	auto addPerformerArtists = [&]
-	{
-		TrackArtistLink::FindParameters params;
-		params.setRelease(releaseId);
-		params.setLinkType(TrackArtistLinkType::Performer);
-		const auto links {TrackArtistLink::find(LmsApp->getDbSession(), params)};
-		if (links.results.empty())
-			return;
-
-		for (const TrackArtistLinkId linkId : links.results)
-		{
-			const TrackArtistLink::pointer link {TrackArtistLink::find(LmsApp->getDbSession(), linkId)};
-			if (!link)
-				continue;
-
-			artistMap[std::string {link->getSubType()}].insert(link->getArtist()->getId());
-		}
-	};
-
-	addArtists(TrackArtistLinkType::Composer, "Lms.Explore.Artists.linktype-composer");
-	addArtists(TrackArtistLinkType::Conductor, "Lms.Explore.Artists.linktype-conductor");
-	addArtists(TrackArtistLinkType::Lyricist, "Lms.Explore.Artists.linktype-lyricist");
-	addArtists(TrackArtistLinkType::Mixer, "Lms.Explore.Artists.linktype-mixer");
-	addArtists(TrackArtistLinkType::Remixer, "Lms.Explore.Artists.linktype-remixer");
-	addArtists(TrackArtistLinkType::Producer, "Lms.Explore.Artists.linktype-producer");
-	addPerformerArtists();
-
-	if (auto itRolelessPerformers {artistMap.find("")}; itRolelessPerformers != std::cend(artistMap))
-	{
-		Wt::WString performersStr {Wt::WString::trn("Lms.Explore.Artists.linktype-performer", itRolelessPerformers->second.size())};
-		artistMap[performersStr] = std::move(itRolelessPerformers->second);
-		artistMap.erase(itRolelessPerformers);
-	}
-
-	if (!artistMap.empty())
-	{
-		releaseInfo->setCondition("if-has-artist", true);
-		Wt::WContainerWidget* artistTable {releaseInfo->bindNew<Wt::WContainerWidget>("artist-table")};
-
-		for (const auto& [role, artistIds] : artistMap)
-		{
-			std::unique_ptr<Wt::WContainerWidget> artistContainer {Utils::createArtistAnchorList(std::vector (std::cbegin(artistIds), std::cend(artistIds)))};
-			auto artistsEntry {std::make_unique<Template>(Wt::WString::tr("Lms.Explore.template.info.artists"))};
-			artistsEntry->bindString("type", role);
-			artistsEntry->bindWidget("artist-container", std::move(artistContainer));
-			artistTable->addWidget(std::move(artistsEntry));
-		}
-	}
-
-	// TODO: save in DB and mean all this
-	for (TrackId trackId : Track::find(LmsApp->getDbSession(), Track::FindParameters {}.setRelease(releaseId).setRange(Range {0, 1})).results)
-	{
-		const Track::pointer track {Track::find(LmsApp->getDbSession(), trackId)};
-		if (!track)
-			continue;
-
-		if (const auto audioFile {Av::parseAudioFile(track->getPath())})
-		{
-			const std::optional<Av::StreamInfo> audioStream {audioFile->getBestStreamInfo()};
-			if (audioStream)
-			{
-				releaseInfo->setCondition("if-has-codec", true);
-				releaseInfo->bindString("codec", audioStream->codec);
-				if (audioStream->bitrate)
-				{
-					releaseInfo->setCondition("if-has-bitrate", true);
-					releaseInfo->bindString("bitrate", std::to_string(audioStream->bitrate / 1000) + " kbps");
-					break;
-				}
-			}
-		}
-	}
-
-	Wt::WPushButton* okBtn {releaseInfo->bindNew<Wt::WPushButton>("ok-btn", Wt::WString::tr("Lms.ok"))};
-	okBtn->clicked().connect([=]
-	{
-		LmsApp->getModalManager().dispose(releaseInfoPtr);
-	});
-
-	LmsApp->getModalManager().show(std::move(releaseInfo));
-}
-
-Release::Release(Filters& filters, PlayQueueController& playQueueController)
-: Template {Wt::WString::tr("Lms.Explore.Release.template")}
-, _filters {filters}
-, _playQueueController {playQueueController}
-{
-	addFunction("tr", &Wt::WTemplate::Functions::tr);
-	addFunction("id", &Wt::WTemplate::Functions::id);
-
-	wApp->internalPathChanged().connect(this, [this]
-	{
-		refreshView();
-	});
-
-	_filters.updated().connect([this]
-	{
-		_needForceRefresh = true;
-		refreshView();
-	});
-
-	refreshView();
-}
-
-static
-std::optional<ReleaseId>
-extractReleaseIdFromInternalPath()
-{
-	if (wApp->internalPathMatches("/release/mbid/"))
-	{
-		const auto mbid {UUID::fromString(wApp->internalPathNextPart("/release/mbid/"))};
-		if (mbid)
-		{
-			auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-			if (const Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), *mbid)})
-				return release->getId();
-		}
-
-		return std::nullopt;
-	}
-
-	return StringUtils::readAs<ReleaseId::ValueType>(wApp->internalPathNextPart("/release/"));
-}
-
-
-void
-Release::refreshView()
-{
-	if (!wApp->internalPathMatches("/release/"))
-		return;
-
-	const auto releaseId {extractReleaseIdFromInternalPath()};
-
-	// consider everything is up to date is the same release is being rendered
-	if (!_needForceRefresh && releaseId && *releaseId == _releaseId)
-		return;
-
-	clear();
-	_releaseId = {};
-	_needForceRefresh = false;
-
-	if (!releaseId)
-		throw ReleaseNotFoundException {};
-
-	auto similarReleasesIds {Service<Recommendation::IRecommendationService>::get()->getSimilarReleases(*releaseId, 6)};
-
-    auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-
-	const Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), *releaseId)};
-	if (!release)
-		throw ReleaseNotFoundException {};
-
-	LmsApp->setTitle(release->getName());
-	_releaseId = *releaseId;
-
-	refreshCopyright(release);
-	refreshLinks(release);
-	refreshSimilarReleases(similarReleasesIds);
-
-	bindString("name", Wt::WString::fromUTF8(release->getName()), Wt::TextFormat::Plain);
-
-	Wt::WString year {ReleaseHelpers::buildReleaseYearString(release->getReleaseDate(), release->getOriginalReleaseDate())};
-	if (!year.empty())
-	{
-		setCondition("if-has-year", true);
-		bindString("year", year, Wt::TextFormat::Plain);
-	}
-
-	bindString("duration", Utils::durationToString(release->getDuration()), Wt::TextFormat::Plain);
-
-	refreshReleaseArtists(release);
-
-	bindWidget<Wt::WImage>("cover", Utils::createCover(release->getId(), CoverResource::Size::Large));
-
-	Wt::WContainerWidget* clusterContainers {bindNew<Wt::WContainerWidget>("clusters")};
-	{
-		const auto clusterTypes {ScanSettings::get(LmsApp->getDbSession())->getClusterTypes()};
-		const auto clusterGroups {release->getClusterGroups(clusterTypes, 3)};
-
-		for (const auto& clusters : clusterGroups)
-		{
-			for (const Database::Cluster::pointer& cluster : clusters)
-			{
-				const ClusterId clusterId {cluster->getId()};
-				Wt::WInteractWidget* entry {clusterContainers->addWidget(Utils::createCluster(clusterId))};
-				entry->clicked().connect([=]
-				{
-					_filters.add(clusterId);
-				});
-			}
-		}
-	}
-
-	bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML)
-		->clicked().connect([=]
-		{
-			_playQueueController.processCommand(PlayQueueController::Command::Play, {_releaseId});
-		});
-
-	bindNew<Wt::WPushButton>("play-shuffled", Wt::WString::tr("Lms.Explore.play-shuffled"), Wt::TextFormat::Plain)
-		->clicked().connect([=]
-		{
-			_playQueueController.processCommand(PlayQueueController::Command::PlayShuffled, {_releaseId});
-		});
-
-	bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"), Wt::TextFormat::Plain)
-		->clicked().connect([=]
-		{
-			_playQueueController.processCommand(PlayQueueController::Command::PlayNext, {_releaseId});
-		});
-
-	bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"), Wt::TextFormat::Plain)
-		->clicked().connect([=]
-		{
-			_playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, {_releaseId});
-		});
-
-	bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
-		->setLink(Wt::WLink {std::make_unique<DownloadReleaseResource>(_releaseId)});
-
-	bindNew<Wt::WPushButton>("release-info", Wt::WString::tr("Lms.Explore.release-info"))
-		->clicked().connect([=]
-		{
-			showReleaseInfoModal(_releaseId);
-		});
-
-	{
-		auto isStarred {[=] { return Service<Scrobbling::IScrobblingService>::get()->isStarred(LmsApp->getUserId(), _releaseId); }};
-
-		Wt::WPushButton* starBtn {bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star"))};
-		starBtn->clicked().connect([=]
-		{
-			if (isStarred())
-			{
-				Service<Scrobbling::IScrobblingService>::get()->unstar(LmsApp->getUserId(), _releaseId);
-				starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
-			}
-			else
-			{
-				Service<Scrobbling::IScrobblingService>::get()->star(LmsApp->getUserId(), _releaseId);
-				starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
-			}
-		});
-	}
-
-	Wt::WContainerWidget* rootContainer {bindNew<Wt::WContainerWidget>("container")};
-
-	const bool variousArtists {release->hasVariousArtists()};
-	const auto totalDisc {release->getTotalDisc()};
-	const std::size_t discCount {release->getDiscCount()};
-	const bool isReleaseMultiDisc {(discCount > 1) || (totalDisc && *totalDisc > 1)};
-
-	// Expect to be called in asc order
-	std::map<std::size_t, Wt::WContainerWidget*> trackContainers;
-	auto getOrAddDiscContainer = [&](std::size_t discNumber, const std::string& discSubtitle) -> Wt::WContainerWidget*
-	{
-		{
-			auto it = trackContainers.find(discNumber);
-			if (it != std::cend(trackContainers))
-				return it->second;
-		}
-
-		Wt::WTemplate* disc {rootContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Release.template.entry-disc"))};
-
-		if (discSubtitle.empty())
-			disc->bindNew<Wt::WText>("disc-title", Wt::WString::tr("Lms.Explore.Release.disc").arg(discNumber));
-		else
-			disc->bindString("disc-title", Wt::WString::fromUTF8(discSubtitle), Wt::TextFormat::Plain);
-
-		Wt::WContainerWidget* tracksContainer {disc->bindNew<Wt::WContainerWidget>("tracks")};
-		trackContainers[discNumber] = tracksContainer;
-
-		return tracksContainer;
-	};
-
-	Wt::WContainerWidget* noDiscTracksContainer{};
-	auto getOrAddNoDiscContainer =  [&]
-	{
-		if (noDiscTracksContainer)
-			return noDiscTracksContainer;
-
-		Wt::WTemplate* disc {rootContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Release.template.entry-nodisc"))};
-		noDiscTracksContainer = disc->bindNew<Wt::WContainerWidget>("tracks");
-
-		return noDiscTracksContainer;
-	};
-
-	Database::Track::FindParameters params;
-	params.setRelease(_releaseId);
-	params.setSortMethod(Database::TrackSortMethod::Release);
-	params.setClusters(_filters.getClusterIds());
-
-	const auto tracks {Database::Track::find(LmsApp->getDbSession(), params)};
-	for (const Database::TrackId trackId : tracks.results)
-	{
-		const Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), trackId)};
-
-		const auto discNumber {track->getDiscNumber()};
-
-		Wt::WContainerWidget* container;
-		if (isReleaseMultiDisc && discNumber)
-			container = getOrAddDiscContainer(*discNumber, track->getDiscSubtitle());
-		else
-			container = getOrAddNoDiscContainer();
-
-		Template* entry {container->addNew<Template>(Wt::WString::tr("Lms.Explore.Release.template.entry"))};
-
-		entry->bindString("name", Wt::WString::fromUTF8(track->getName()), Wt::TextFormat::Plain);
-
-		const auto artists {track->getArtistIds({TrackArtistLinkType::Artist})};
-		if (variousArtists && !artists.empty())
-		{
-			entry->setCondition("if-has-artists", true);
-			entry->bindWidget("artists", Utils::createArtistDisplayNameWithAnchors(track->getArtistDisplayName(), artists));
-			entry->bindWidget("artists-md", Utils::createArtistDisplayNameWithAnchors(track->getArtistDisplayName(),artists));
-		}
-
-		auto trackNumber {track->getTrackNumber()};
-		if (trackNumber)
-		{
-			entry->setCondition("if-has-track-number", true);
-			entry->bindInt("track-number", *trackNumber);
-		}
-
-		Wt::WPushButton* playBtn {entry->bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.template.play-btn"), Wt::TextFormat::XHTML)};
-		playBtn->clicked().connect([=]
-		{
-			_playQueueController.playTrackInRelease(trackId);
-		});
-
-		{
-			entry->bindNew<Wt::WPushButton>("more-btn", Wt::WString::tr("Lms.template.more-btn"), Wt::TextFormat::XHTML);
-			entry->bindNew<Wt::WPushButton>("play", Wt::WString::tr("Lms.Explore.play"))
-				->clicked().connect([=]
-				{
-					_playQueueController.playTrackInRelease(trackId);
-				});
-			entry->bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"))
-				->clicked().connect([=]
-				{
-					_playQueueController.processCommand(PlayQueueController::Command::PlayNext, {trackId});
-				});
-			entry->bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"))
-				->clicked().connect([=]
-				{
-					_playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, {trackId});
-				});
-
-			auto isStarred {[=] { return Service<Scrobbling::IScrobblingService>::get()->isStarred(LmsApp->getUserId(), trackId); }};
-
-			Wt::WPushButton* starBtn {entry->bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star"))};
-			starBtn->clicked().connect([=]
-			{
-				auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
-
-				if (isStarred())
-				{
-					Service<Scrobbling::IScrobblingService>::get()->unstar(LmsApp->getUserId(), trackId);
-					starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
-				}
-				else
-				{
-					Service<Scrobbling::IScrobblingService>::get()->star(LmsApp->getUserId(), trackId);
-					starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
-				}
-			});
-
-			entry->bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
-				->setLink(Wt::WLink {std::make_unique<DownloadTrackResource>(trackId)});
-
-			entry->bindNew<Wt::WPushButton>("track-info", Wt::WString::tr("Lms.Explore.track-info"))
-				->clicked().connect([=] { TrackListHelpers::showTrackInfoModal(trackId, _filters); });
-		}
-
-		entry->bindString("duration", Utils::durationToString(track->getDuration()), Wt::TextFormat::Plain);
-
-		LmsApp->getMediaPlayer().trackLoaded.connect(entry, [=] (TrackId loadedTrackId)
-		{
-			entry->toggleStyleClass("Lms-entry-playing", loadedTrackId == trackId);
-		});
-
-		if (auto trackIdLoaded {LmsApp->getMediaPlayer().getTrackLoaded()})
-		{
-			entry->toggleStyleClass("Lms-entry-playing", *trackIdLoaded == trackId);
-		}
-		else
-			entry->removeStyleClass("Lms-entry-playing");
-	}
-}
-
-void
-Release::refreshReleaseArtists(const Database::Release::pointer& release)
-{
-	auto container{ Utils::createArtistsAnchorsForRelease(release) };
-	if (container)
-	{
-		setCondition("if-has-release-artists", true);
-		bindWidget("artists", std::move(container));
-	}
-}
-
-void
-Release::refreshCopyright(const Database::Release::pointer& release)
-{
-	std::optional<std::string> copyright {release->getCopyright()};
-	std::optional<std::string> copyrightURL {release->getCopyrightURL()};
-
-	if (!copyright && !copyrightURL)
-		return;
-
-	setCondition("if-has-copyright", true);
-
-	std::string copyrightText {copyright ? *copyright : ""};
-	if (copyrightText.empty() && copyrightURL)
-		copyrightText = *copyrightURL;
-
-	if (copyrightURL)
-	{
-		Wt::WLink link {*copyrightURL};
-		link.setTarget(Wt::LinkTarget::NewWindow);
-
-		Wt::WAnchor* anchor {bindNew<Wt::WAnchor>("copyright", link)};
-		anchor->setTextFormat(Wt::TextFormat::Plain);
-		anchor->setText(Wt::WString::fromUTF8(copyrightText));
-	}
-	else
-		bindString("copyright", Wt::WString::fromUTF8(*copyright), Wt::TextFormat::Plain);
-}
-
-void
-Release::refreshLinks(const Database::Release::pointer& release)
-{
-	const auto mbid {release->getMBID()};
-	if (mbid)
-	{
-		setCondition("if-has-mbid", true);
-		bindString("mbid-link", std::string {"https://musicbrainz.org/release/"} + std::string {mbid->getAsString()});
-	}
-}
-
-void
-Release::refreshSimilarReleases(const std::vector<ReleaseId>& similarReleasesId)
-{
-	if (similarReleasesId.empty())
-		return;
-
-	setCondition("if-has-similar-releases", true);
-	auto* similarReleasesContainer {bindNew<Wt::WContainerWidget>("similar-releases")};
-
-	for (const ReleaseId id : similarReleasesId)
-	{
-		const Database::Release::pointer similarRelease {Database::Release::find(LmsApp->getDbSession(), id)};
-		if (!similarRelease)
-			continue;
-
-		similarReleasesContainer->addWidget(ReleaseListHelpers::createEntry(similarRelease));
-	}
-}
+    namespace
+    {
+        void showReleaseInfoModal(Database::ReleaseId releaseId)
+        {
+            auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+
+            const Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), releaseId) };
+            if (!release)
+                return;
+
+            auto releaseInfo{ std::make_unique<Template>(Wt::WString::tr("Lms.Explore.Release.template.release-info")) };
+            Wt::WWidget* releaseInfoPtr{ releaseInfo.get() };
+            releaseInfo->addFunction("tr", &Wt::WTemplate::Functions::tr);
+
+            if (auto primaryReleaseType{ release->getPrimaryType() })
+            {
+                releaseInfo->setCondition("if-has-release-type", true);
+                releaseInfo->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(*primaryReleaseType, release->getSecondaryTypes()));
+            }
+
+            std::map<Wt::WString, std::set<ArtistId>> artistMap;
+
+            auto addArtists = [&](TrackArtistLinkType linkType, const char* type)
+                {
+                    Artist::FindParameters params;
+                    params.setRelease(releaseId);
+                    params.setLinkType(linkType);
+                    const auto artistIds{ Artist::findIds(LmsApp->getDbSession(), params) };
+                    if (artistIds.results.empty())
+                        return;
+
+                    Wt::WString typeStr{ Wt::WString::trn(type, artistIds.results.size()) };
+                    for (ArtistId artistId : artistIds.results)
+                        artistMap[typeStr].insert(artistId);
+                };
+
+            auto addPerformerArtists = [&]
+                {
+                    TrackArtistLink::FindParameters params;
+                    params.setRelease(releaseId);
+                    params.setLinkType(TrackArtistLinkType::Performer);
+                    const auto links{ TrackArtistLink::find(LmsApp->getDbSession(), params) };
+                    if (links.results.empty())
+                        return;
+
+                    for (const TrackArtistLinkId linkId : links.results)
+                    {
+                        const TrackArtistLink::pointer link{ TrackArtistLink::find(LmsApp->getDbSession(), linkId) };
+                        if (!link)
+                            continue;
+
+                        artistMap[std::string{ link->getSubType() }].insert(link->getArtist()->getId());
+                    }
+                };
+
+            addArtists(TrackArtistLinkType::Composer, "Lms.Explore.Artists.linktype-composer");
+            addArtists(TrackArtistLinkType::Conductor, "Lms.Explore.Artists.linktype-conductor");
+            addArtists(TrackArtistLinkType::Lyricist, "Lms.Explore.Artists.linktype-lyricist");
+            addArtists(TrackArtistLinkType::Mixer, "Lms.Explore.Artists.linktype-mixer");
+            addArtists(TrackArtistLinkType::Remixer, "Lms.Explore.Artists.linktype-remixer");
+            addArtists(TrackArtistLinkType::Producer, "Lms.Explore.Artists.linktype-producer");
+            addPerformerArtists();
+
+            if (auto itRolelessPerformers{ artistMap.find("") }; itRolelessPerformers != std::cend(artistMap))
+            {
+                Wt::WString performersStr{ Wt::WString::trn("Lms.Explore.Artists.linktype-performer", itRolelessPerformers->second.size()) };
+                artistMap[performersStr] = std::move(itRolelessPerformers->second);
+                artistMap.erase(itRolelessPerformers);
+            }
+
+            if (!artistMap.empty())
+            {
+                releaseInfo->setCondition("if-has-artist", true);
+                Wt::WContainerWidget* artistTable{ releaseInfo->bindNew<Wt::WContainerWidget>("artist-table") };
+
+                for (const auto& [role, artistIds] : artistMap)
+                {
+                    std::unique_ptr<Wt::WContainerWidget> artistContainer{ Utils::createArtistAnchorList(std::vector(std::cbegin(artistIds), std::cend(artistIds))) };
+                    auto artistsEntry{ std::make_unique<Template>(Wt::WString::tr("Lms.Explore.template.info.artists")) };
+                    artistsEntry->bindString("type", role);
+                    artistsEntry->bindWidget("artist-container", std::move(artistContainer));
+                    artistTable->addWidget(std::move(artistsEntry));
+                }
+            }
+
+            // TODO: save in DB and mean all this
+            for (const Track::pointer& track : Track::find(LmsApp->getDbSession(), Track::FindParameters{}.setRelease(releaseId).setRange(Range{ 0, 1 })).results)
+            {
+                if (const auto audioFile{ Av::parseAudioFile(track->getPath()) })
+                {
+                    const std::optional<Av::StreamInfo> audioStream{ audioFile->getBestStreamInfo() };
+                    if (audioStream)
+                    {
+                        releaseInfo->setCondition("if-has-codec", true);
+                        releaseInfo->bindString("codec", audioStream->codec);
+                        if (audioStream->bitrate)
+                        {
+                            releaseInfo->setCondition("if-has-bitrate", true);
+                            releaseInfo->bindString("bitrate", std::to_string(audioStream->bitrate / 1000) + " kbps");
+                            break;
+                        }
+                    }
+                }
+            }
+
+            Wt::WPushButton* okBtn{ releaseInfo->bindNew<Wt::WPushButton>("ok-btn", Wt::WString::tr("Lms.ok")) };
+            okBtn->clicked().connect([=]
+                {
+                    LmsApp->getModalManager().dispose(releaseInfoPtr);
+                });
+
+            LmsApp->getModalManager().show(std::move(releaseInfo));
+        }
+
+        std::optional<ReleaseId> extractReleaseIdFromInternalPath()
+        {
+            if (wApp->internalPathMatches("/release/mbid/"))
+            {
+                const auto mbid{ UUID::fromString(wApp->internalPathNextPart("/release/mbid/")) };
+                if (mbid)
+                {
+                    auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                    if (const Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), *mbid) })
+                        return release->getId();
+                }
+
+                return std::nullopt;
+            }
+
+            return StringUtils::readAs<ReleaseId::ValueType>(wApp->internalPathNextPart("/release/"));
+        }
+    }
+
+    Release::Release(Filters& filters, PlayQueueController& playQueueController)
+        : Template{ Wt::WString::tr("Lms.Explore.Release.template") }
+        , _filters{ filters }
+        , _playQueueController{ playQueueController }
+    {
+        addFunction("tr", &Wt::WTemplate::Functions::tr);
+        addFunction("id", &Wt::WTemplate::Functions::id);
+
+        wApp->internalPathChanged().connect(this, [this]
+            {
+                refreshView();
+            });
+
+        _filters.updated().connect([this]
+            {
+                _needForceRefresh = true;
+                refreshView();
+            });
+
+        refreshView();
+    }
+
+    void Release::refreshView()
+    {
+        if (!wApp->internalPathMatches("/release/"))
+            return;
+
+        const auto releaseId{ extractReleaseIdFromInternalPath() };
+
+        // consider everything is up to date is the same release is being rendered
+        if (!_needForceRefresh && releaseId && *releaseId == _releaseId)
+            return;
+
+        clear();
+        _releaseId = {};
+        _needForceRefresh = false;
+
+        if (!releaseId)
+            throw ReleaseNotFoundException{};
+
+        auto similarReleasesIds{ Service<Recommendation::IRecommendationService>::get()->getSimilarReleases(*releaseId, 6) };
+
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+
+        const Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), *releaseId) };
+        if (!release)
+            throw ReleaseNotFoundException{};
+
+        LmsApp->setTitle(release->getName());
+        _releaseId = *releaseId;
+
+        refreshCopyright(release);
+        refreshLinks(release);
+        refreshSimilarReleases(similarReleasesIds);
+
+        bindString("name", Wt::WString::fromUTF8(release->getName()), Wt::TextFormat::Plain);
+
+        Wt::WString year{ ReleaseHelpers::buildReleaseYearString(release->getReleaseDate(), release->getOriginalReleaseDate()) };
+        if (!year.empty())
+        {
+            setCondition("if-has-year", true);
+            bindString("year", year, Wt::TextFormat::Plain);
+        }
+
+        bindString("duration", Utils::durationToString(release->getDuration()), Wt::TextFormat::Plain);
+
+        refreshReleaseArtists(release);
+
+        bindWidget<Wt::WImage>("cover", Utils::createCover(release->getId(), CoverResource::Size::Large));
+
+        Wt::WContainerWidget* clusterContainers{ bindNew<Wt::WContainerWidget>("clusters") };
+        {
+            const auto clusterTypes{ ScanSettings::get(LmsApp->getDbSession())->getClusterTypes() };
+            const auto clusterGroups{ release->getClusterGroups(clusterTypes, 3) };
+
+            for (const auto& clusters : clusterGroups)
+            {
+                for (const Database::Cluster::pointer& cluster : clusters)
+                {
+                    const ClusterId clusterId{ cluster->getId() };
+                    Wt::WInteractWidget* entry{ clusterContainers->addWidget(Utils::createCluster(clusterId)) };
+                    entry->clicked().connect([=]
+                        {
+                            _filters.add(clusterId);
+                        });
+                }
+            }
+        }
+
+        bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML)
+            ->clicked().connect([=]
+                {
+                    _playQueueController.processCommand(PlayQueueController::Command::Play, { _releaseId });
+                });
+
+        bindNew<Wt::WPushButton>("play-shuffled", Wt::WString::tr("Lms.Explore.play-shuffled"), Wt::TextFormat::Plain)
+            ->clicked().connect([=]
+                {
+                    _playQueueController.processCommand(PlayQueueController::Command::PlayShuffled, { _releaseId });
+                });
+
+        bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"), Wt::TextFormat::Plain)
+            ->clicked().connect([=]
+                {
+                    _playQueueController.processCommand(PlayQueueController::Command::PlayNext, { _releaseId });
+                });
+
+        bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"), Wt::TextFormat::Plain)
+            ->clicked().connect([=]
+                {
+                    _playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, { _releaseId });
+                });
+
+        bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
+            ->setLink(Wt::WLink{ std::make_unique<DownloadReleaseResource>(_releaseId) });
+
+        bindNew<Wt::WPushButton>("release-info", Wt::WString::tr("Lms.Explore.release-info"))
+            ->clicked().connect([=]
+                {
+                    showReleaseInfoModal(_releaseId);
+                });
+
+        {
+            auto isStarred{ [=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), _releaseId); } };
+
+            Wt::WPushButton* starBtn{ bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star")) };
+            starBtn->clicked().connect([=]
+                {
+                    if (isStarred())
+                    {
+                        Service<Feedback::IFeedbackService>::get()->unstar(LmsApp->getUserId(), _releaseId);
+                        starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
+                    }
+                    else
+                    {
+                        Service<Feedback::IFeedbackService>::get()->star(LmsApp->getUserId(), _releaseId);
+                        starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
+                    }
+                });
+        }
+
+        Wt::WContainerWidget* rootContainer{ bindNew<Wt::WContainerWidget>("container") };
+
+        const bool variousArtists{ release->hasVariousArtists() };
+        const auto totalDisc{ release->getTotalDisc() };
+        const std::size_t discCount{ release->getDiscCount() };
+        const bool isReleaseMultiDisc{ (discCount > 1) || (totalDisc && *totalDisc > 1) };
+
+        // Expect to be called in asc order
+        std::map<std::size_t, Wt::WContainerWidget*> trackContainers;
+        auto getOrAddDiscContainer = [&](std::size_t discNumber, const std::string& discSubtitle) -> Wt::WContainerWidget*
+            {
+                {
+                    auto it = trackContainers.find(discNumber);
+                    if (it != std::cend(trackContainers))
+                        return it->second;
+                }
+
+                Wt::WTemplate* disc{ rootContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Release.template.entry-disc")) };
+
+                if (discSubtitle.empty())
+                    disc->bindNew<Wt::WText>("disc-title", Wt::WString::tr("Lms.Explore.Release.disc").arg(discNumber));
+                else
+                    disc->bindString("disc-title", Wt::WString::fromUTF8(discSubtitle), Wt::TextFormat::Plain);
+
+                Wt::WContainerWidget* tracksContainer{ disc->bindNew<Wt::WContainerWidget>("tracks") };
+                trackContainers[discNumber] = tracksContainer;
+
+                return tracksContainer;
+            };
+
+        Wt::WContainerWidget* noDiscTracksContainer{};
+        auto getOrAddNoDiscContainer = [&]
+            {
+                if (noDiscTracksContainer)
+                    return noDiscTracksContainer;
+
+                Wt::WTemplate* disc{ rootContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Release.template.entry-nodisc")) };
+                noDiscTracksContainer = disc->bindNew<Wt::WContainerWidget>("tracks");
+
+                return noDiscTracksContainer;
+            };
+
+        Database::Track::FindParameters params;
+        params.setRelease(_releaseId);
+        params.setSortMethod(Database::TrackSortMethod::Release);
+        params.setClusters(_filters.getClusterIds());
+
+        for (const Database::Track::pointer& track : Database::Track::find(LmsApp->getDbSession(), params).results)
+        {
+            const Database::TrackId trackId{ track->getId() };
+            const auto discNumber{ track->getDiscNumber() };
+
+            Wt::WContainerWidget* container;
+            if (isReleaseMultiDisc && discNumber)
+                container = getOrAddDiscContainer(*discNumber, track->getDiscSubtitle());
+            else
+                container = getOrAddNoDiscContainer();
+
+            Template* entry{ container->addNew<Template>(Wt::WString::tr("Lms.Explore.Release.template.entry")) };
+
+            entry->bindString("name", Wt::WString::fromUTF8(track->getName()), Wt::TextFormat::Plain);
+
+            const auto artists{ track->getArtistIds({TrackArtistLinkType::Artist}) };
+            if (variousArtists && !artists.empty())
+            {
+                entry->setCondition("if-has-artists", true);
+                entry->bindWidget("artists", Utils::createArtistDisplayNameWithAnchors(track->getArtistDisplayName(), artists));
+                entry->bindWidget("artists-md", Utils::createArtistDisplayNameWithAnchors(track->getArtistDisplayName(), artists));
+            }
+
+            auto trackNumber{ track->getTrackNumber() };
+            if (trackNumber)
+            {
+                entry->setCondition("if-has-track-number", true);
+                entry->bindInt("track-number", *trackNumber);
+            }
+
+            Wt::WPushButton* playBtn{ entry->bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.template.play-btn"), Wt::TextFormat::XHTML) };
+            playBtn->clicked().connect([=]
+                {
+                    _playQueueController.playTrackInRelease(trackId);
+                });
+
+            {
+                entry->bindNew<Wt::WPushButton>("more-btn", Wt::WString::tr("Lms.template.more-btn"), Wt::TextFormat::XHTML);
+                entry->bindNew<Wt::WPushButton>("play", Wt::WString::tr("Lms.Explore.play"))
+                    ->clicked().connect([=]
+                        {
+                            _playQueueController.playTrackInRelease(trackId);
+                        });
+                entry->bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"))
+                    ->clicked().connect([=]
+                        {
+                            _playQueueController.processCommand(PlayQueueController::Command::PlayNext, { trackId });
+                        });
+                entry->bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"))
+                    ->clicked().connect([=]
+                        {
+                            _playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, { trackId });
+                        });
+
+                auto isStarred{ [=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), trackId); } };
+
+                Wt::WPushButton* starBtn{ entry->bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star")) };
+                starBtn->clicked().connect([=]
+                    {
+                        auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
+
+                        if (isStarred())
+                        {
+                            Service<Feedback::IFeedbackService>::get()->unstar(LmsApp->getUserId(), trackId);
+                            starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
+                        }
+                        else
+                        {
+                            Service<Feedback::IFeedbackService>::get()->star(LmsApp->getUserId(), trackId);
+                            starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
+                        }
+                    });
+
+                entry->bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
+                    ->setLink(Wt::WLink{ std::make_unique<DownloadTrackResource>(trackId) });
+
+                entry->bindNew<Wt::WPushButton>("track-info", Wt::WString::tr("Lms.Explore.track-info"))
+                    ->clicked().connect([=] { TrackListHelpers::showTrackInfoModal(trackId, _filters); });
+            }
+
+            entry->bindString("duration", Utils::durationToString(track->getDuration()), Wt::TextFormat::Plain);
+
+            LmsApp->getMediaPlayer().trackLoaded.connect(entry, [=](TrackId loadedTrackId)
+                {
+                    entry->toggleStyleClass("Lms-entry-playing", loadedTrackId == trackId);
+                });
+
+            if (auto trackIdLoaded{ LmsApp->getMediaPlayer().getTrackLoaded() })
+            {
+                entry->toggleStyleClass("Lms-entry-playing", *trackIdLoaded == trackId);
+            }
+            else
+                entry->removeStyleClass("Lms-entry-playing");
+        }
+    }
+
+    void Release::refreshReleaseArtists(const Database::Release::pointer& release)
+    {
+        auto container{ Utils::createArtistsAnchorsForRelease(release) };
+        if (container)
+        {
+            setCondition("if-has-release-artists", true);
+            bindWidget("artists", std::move(container));
+        }
+    }
+
+    void Release::refreshCopyright(const Database::Release::pointer& release)
+    {
+        std::optional<std::string> copyright{ release->getCopyright() };
+        std::optional<std::string> copyrightURL{ release->getCopyrightURL() };
+
+        if (!copyright && !copyrightURL)
+            return;
+
+        setCondition("if-has-copyright", true);
+
+        std::string copyrightText{ copyright ? *copyright : "" };
+        if (copyrightText.empty() && copyrightURL)
+            copyrightText = *copyrightURL;
+
+        if (copyrightURL)
+        {
+            Wt::WLink link{ *copyrightURL };
+            link.setTarget(Wt::LinkTarget::NewWindow);
+
+            Wt::WAnchor* anchor{ bindNew<Wt::WAnchor>("copyright", link) };
+            anchor->setTextFormat(Wt::TextFormat::Plain);
+            anchor->setText(Wt::WString::fromUTF8(copyrightText));
+        }
+        else
+            bindString("copyright", Wt::WString::fromUTF8(*copyright), Wt::TextFormat::Plain);
+    }
+
+    void Release::refreshLinks(const Database::Release::pointer& release)
+    {
+        const auto mbid{ release->getMBID() };
+        if (mbid)
+        {
+            setCondition("if-has-mbid", true);
+            bindString("mbid-link", std::string{ "https://musicbrainz.org/release/" } + std::string{ mbid->getAsString() });
+        }
+    }
+
+    void Release::refreshSimilarReleases(const std::vector<ReleaseId>& similarReleasesId)
+    {
+        if (similarReleasesId.empty())
+            return;
+
+        setCondition("if-has-similar-releases", true);
+        auto* similarReleasesContainer{ bindNew<Wt::WContainerWidget>("similar-releases") };
+
+        for (const ReleaseId id : similarReleasesId)
+        {
+            const Database::Release::pointer similarRelease{ Database::Release::find(LmsApp->getDbSession(), id) };
+            if (!similarRelease)
+                continue;
+
+            similarReleasesContainer->addWidget(ReleaseListHelpers::createEntry(similarRelease));
+        }
+    }
 
 } // namespace UserInterface
-
diff --git a/src/lms/ui/explore/SearchView.cpp b/src/lms/ui/explore/SearchView.cpp
index 471f431d..1f05006c 100644
--- a/src/lms/ui/explore/SearchView.cpp
+++ b/src/lms/ui/explore/SearchView.cpp
@@ -19,6 +19,8 @@
 
 #include "SearchView.hpp"
 
+#include <Wt/WPushButton.h>
+
 #include "services/database/Artist.hpp"
 #include "services/database/Release.hpp"
 #include "services/database/Session.hpp"
@@ -35,142 +37,162 @@ using namespace Database;
 
 namespace UserInterface
 {
-	SearchView::SearchView(Filters& filters, PlayQueueController& playQueueController)
-	: Wt::WTemplate {Wt::WString::tr("Lms.Explore.Search.template")}
-	, _playQueueController {playQueueController}
-	, _filters {filters}
-	, _artistCollector {filters, ArtistCollector::Mode::Search, getMaxCount(Mode::Artist)}
-	, _releaseCollector {filters, ReleaseCollector::Mode::Search, getMaxCount(Mode::Release)}
-	, _trackCollector {filters, TrackCollector::Mode::Search, getMaxCount(Mode::Track)}
-	{
-		addFunction("tr", &Wt::WTemplate::Functions::tr);
+    SearchView::SearchView(Filters& filters, PlayQueueController& playQueueController)
+        : Wt::WTemplate{ Wt::WString::tr("Lms.Explore.Search.template") }
+        , _playQueueController{ playQueueController }
+        , _filters{ filters }
+        , _artistCollector{ filters, ArtistCollector::Mode::Search, getMaxCount(Mode::Artist) }
+        , _releaseCollector{ filters, ReleaseCollector::Mode::Search, getMaxCount(Mode::Release) }
+        , _trackCollector{ filters, TrackCollector::Mode::Search, getMaxCount(Mode::Track) }
+    {
+        addFunction("tr", &Wt::WTemplate::Functions::tr);
 
-		_artists = bindNew<InfiniteScrollingContainer>("artists", Wt::WString::tr("Lms.Explore.Artists.template.container"));
-		_artists->onRequestElements.connect([this] { addSomeArtists(); });
+        _stack = bindNew<Wt::WStackedWidget>("results");
 
-		_artistLinkType = bindNew<Wt::WComboBox>("link-type");
-		_artistLinkType->setModel(ArtistListHelpers::createArtistLinkTypesModel());
-		_artistLinkType->changed().connect([this]
-		{
-			const std::optional<TrackArtistLinkType> linkType {static_cast<ArtistLinkTypesModel*>(_artistLinkType->model().get())->getValue(_artistLinkType->currentIndex())};
-			refreshView(linkType);
-		});
+        // releases
+        _releases = _stack->addNew<InfiniteScrollingContainer>(Wt::WString::tr("Lms.Explore.Releases.template.container"));
+        _releases->onRequestElements.connect([this] { addSomeReleases(); });
 
-		_releases = bindNew<InfiniteScrollingContainer>("releases", Wt::WString::tr("Lms.Explore.Releases.template.container"));
-		_releases->onRequestElements.connect([this] { addSomeReleases(); });
+        // artists
+        {
+            Wt::WTemplate* artistResults{ _stack->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Search.template.artists")) };
 
-		_tracks = bindNew<InfiniteScrollingContainer>("tracks");
-		_tracks->onRequestElements.connect([this] { addSomeTracks(); });
+            _artistLinkType = artistResults->bindNew<Wt::WComboBox>("link-type");
+            _artistLinkType->setModel(ArtistListHelpers::createArtistLinkTypesModel());
+            _artistLinkType->changed().connect([this]
+                {
+                    const std::optional<TrackArtistLinkType> linkType{ static_cast<ArtistLinkTypesModel*>(_artistLinkType->model().get())->getValue(_artistLinkType->currentIndex()) };
+                    refreshView(linkType);
+                });
 
-		filters.updated().connect([=]
-		{
-			refreshView();
-		});
+            _artists = artistResults->bindNew<InfiniteScrollingContainer>("artists", Wt::WString::tr("Lms.Explore.Artists.template.container"));
+            _artists->onRequestElements.connect([this] { addSomeArtists(); });
+        }
 
-		LmsApp->getScannerEvents().scanComplete.connect(this, [this](const Scanner::ScanStats& stats)
-		{
-			if (stats.nbChanges())
-				_artistLinkType->setModel(ArtistListHelpers::createArtistLinkTypesModel());
-		});
-	}
+        // Tracks
+        _tracks = _stack->addNew<InfiniteScrollingContainer>();
+        _tracks->onRequestElements.connect([this] { addSomeTracks(); });
 
-	std::size_t
-	SearchView::getBatchSize(Mode mode) const
-	{
-		auto it {_batchSizes.find(mode)};
-		assert(it != _batchSizes.cend());
-		return it->second;
-	}
+        // Menu
+        auto bindMenuItem{ [this](std::size_t index, const std::string& var, const Wt::WString& title)
+        {
+            Wt::WPushButton* menuItem {bindNew<Wt::WPushButton>(var, title)};
+            menuItem->clicked().connect([=]
+            {
+                _stack->setCurrentIndex(index);
+                _currentActiveItem->removeStyleClass("active");
+                menuItem->addStyleClass("active");
+                _currentActiveItem = menuItem;
+            });
 
-	std::size_t
-	SearchView::getMaxCount(Mode mode) const
-	{
-		auto it {_maxCounts.find(mode)};
-		assert(it != _maxCounts.cend());
-		return it->second;
-	}
+            if (index == 0)
+            {
+                _currentActiveItem = menuItem;
+                _currentActiveItem->addStyleClass("active");
+            }
+        } };
 
-	void
-	SearchView::refreshView(std::optional<TrackArtistLinkType> linkType)
-	{
-		_artistCollector.setArtistLinkType(linkType);
-		refreshView();
-	}
+        bindMenuItem(0, "releases", Wt::WString::tr("Lms.Explore.releases"));
+        bindMenuItem(1, "artists", Wt::WString::tr("Lms.Explore.artists"));
+        bindMenuItem(2, "tracks", Wt::WString::tr("Lms.Explore.tracks"));
 
-	void
-	SearchView::refreshView(const Wt::WString& searchText)
-	{
-		_releaseCollector.setSearch(searchText.toUTF8());
-		_artistCollector.setSearch(searchText.toUTF8());
-		_trackCollector.setSearch(searchText.toUTF8());
-		refreshView();
-	}
+        filters.updated().connect([=]
+            {
+                refreshView();
+            });
 
-	void
-	SearchView::refreshView()
-	{
-		_artists->reset();
-		_releases->reset();
-		_tracks->reset();
+        LmsApp->getScannerEvents().scanComplete.connect(this, [this](const Scanner::ScanStats& stats)
+            {
+                if (stats.nbChanges())
+                    _artistLinkType->setModel(ArtistListHelpers::createArtistLinkTypesModel());
+            });
+    }
 
-		addSomeArtists();
-		addSomeReleases();
-		addSomeTracks();
-	}
+    std::size_t SearchView::getBatchSize(Mode mode) const
+    {
+        auto it{ _batchSizes.find(mode) };
+        assert(it != _batchSizes.cend());
+        return it->second;
+    }
 
-	void
-	SearchView::addSomeArtists()
-	{
-		using namespace Database;
+    std::size_t SearchView::getMaxCount(Mode mode) const
+    {
+        auto it{ _maxCounts.find(mode) };
+        assert(it != _maxCounts.cend());
+        return it->second;
+    }
 
-		const Range range {_artists->getCount(), getBatchSize(Mode::Artist)};
-		const RangeResults<ArtistId> artistIds {_artistCollector.get(range)};
-		{
-			auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+    void SearchView::refreshView(std::optional<TrackArtistLinkType> linkType)
+    {
+        _artistCollector.setArtistLinkType(linkType);
+        refreshView();
+    }
 
-			for (const ArtistId artistId : artistIds.results)
-			{
-				const Artist::pointer artist {Artist::find(LmsApp->getDbSession(), artistId)};
-				_artists->add(ArtistListHelpers::createEntry(artist));
-			}
-		}
-	}
+    void SearchView::refreshView(const Wt::WString& searchText)
+    {
+        _releaseCollector.setSearch(searchText.toUTF8());
+        _artistCollector.setSearch(searchText.toUTF8());
+        _trackCollector.setSearch(searchText.toUTF8());
+        refreshView();
+    }
 
-	void
-	SearchView::addSomeReleases()
-	{
-		using namespace Database;
+    void SearchView::refreshView()
+    {
+        _artists->reset();
+        _releases->reset();
+        _tracks->reset();
+    }
 
-		const Range range {_releases->getCount(), getBatchSize(Mode::Release)};
-		const RangeResults<ReleaseId> releaseIds {_releaseCollector.get(range)};
-		{
-			auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+    void SearchView::addSomeArtists()
+    {
+        using namespace Database;
 
-			for (const ReleaseId releaseId : releaseIds.results)
-			{
-				const Release::pointer release {Release::find(LmsApp->getDbSession(), releaseId)};
-				_releases->add(ReleaseListHelpers::createEntry(release));
-			}
-		}
-	}
+        const Range range{ _artists->getCount(), getBatchSize(Mode::Artist) };
+        const RangeResults<ArtistId> artistIds{ _artistCollector.get(range) };
+        {
+            auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-	void
-	SearchView::addSomeTracks()
-	{
-		using namespace Database;
+            for (const ArtistId artistId : artistIds.results)
+            {
+                const Artist::pointer artist{ Artist::find(LmsApp->getDbSession(), artistId) };
+                _artists->add(ArtistListHelpers::createEntry(artist));
+            }
+        }
+    }
 
-		const Range range {_tracks->getCount(), getBatchSize(Mode::Track)};
-		const RangeResults<TrackId> trackIds {_trackCollector.get(range)};
+    void SearchView::addSomeReleases()
+    {
+        using namespace Database;
 
-		{
-			auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+        const Range range{ _releases->getCount(), getBatchSize(Mode::Release) };
+        const RangeResults<ReleaseId> releaseIds{ _releaseCollector.get(range) };
+        {
+            auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-			for (const TrackId trackId : trackIds.results)
-			{
-				const Track::pointer track {Track::find(LmsApp->getDbSession(), trackId)};
-				_tracks->add(TrackListHelpers::createEntry(track, _playQueueController, _filters));
-			}
-		}
-	}
+            for (const ReleaseId releaseId : releaseIds.results)
+            {
+                const Release::pointer release{ Release::find(LmsApp->getDbSession(), releaseId) };
+                _releases->add(ReleaseListHelpers::createEntry(release));
+            }
+        }
+    }
+
+    void SearchView::addSomeTracks()
+    {
+        using namespace Database;
+
+        const Range range{ _tracks->getCount(), getBatchSize(Mode::Track) };
+        const RangeResults<TrackId> trackIds{ _trackCollector.get(range) };
+
+        {
+            auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+
+            for (const TrackId trackId : trackIds.results)
+            {
+                const Track::pointer track{ Track::find(LmsApp->getDbSession(), trackId) };
+                _tracks->add(TrackListHelpers::createEntry(track, _playQueueController, _filters));
+            }
+        }
+    }
 } // namespace UserInterface
 
diff --git a/src/lms/ui/explore/SearchView.hpp b/src/lms/ui/explore/SearchView.hpp
index bc5c33df..5b7f4989 100644
--- a/src/lms/ui/explore/SearchView.hpp
+++ b/src/lms/ui/explore/SearchView.hpp
@@ -33,62 +33,61 @@
 
 namespace UserInterface
 {
-	class InfiniteScrollingContainer;
-	class Filters;
-	class PlayQueueController;
+    class InfiniteScrollingContainer;
+    class Filters;
+    class PlayQueueController;
 
-	class SearchView : public Wt::WTemplate
-	{
-		public:
-			SearchView(Filters& filters, PlayQueueController& playQueueController);
+    class SearchView : public Wt::WTemplate
+    {
+    public:
+        SearchView(Filters& filters, PlayQueueController& playQueueController);
 
-			void refreshView(const Wt::WString& searchText);
+        void refreshView(const Wt::WString& searchText);
 
-		private:
-			// same order as in the menu
-			enum class Mode
-			{
-				Artist,
-				Release,
-				Track,
-			};
+    private:
+        // same order as in the menu
+        enum class Mode
+        {
+            Artist,
+            Release,
+            Track,
+        };
 
-			static constexpr Mode _defaultMode {Mode::Release};
-			static inline std::unordered_map<Mode, std::size_t> _batchSizes
-			{
-				{Mode::Artist, 6},
-				{Mode::Release, 6},
-				{Mode::Track, 6},
-			};
-			static inline std::unordered_map<Mode, std::size_t> _maxCounts
-			{
-				{Mode::Artist, 8000},
-				{Mode::Release, 4000},
-				{Mode::Track, 4000},
-			};
-			std::size_t getBatchSize(Mode mode) const;
-			std::size_t getMaxCount(Mode mode) const;
+        static constexpr Mode _defaultMode{ Mode::Release };
+        static inline std::unordered_map<Mode, std::size_t> _batchSizes
+        {
+            {Mode::Artist, 6},
+            {Mode::Release, 6},
+            {Mode::Track, 6},
+        };
+        static inline std::unordered_map<Mode, std::size_t> _maxCounts
+        {
+            {Mode::Artist, 1000},
+            {Mode::Release, 504},
+            {Mode::Track, 500},
+        };
+        std::size_t getBatchSize(Mode mode) const;
+        std::size_t getMaxCount(Mode mode) const;
 
-			void refreshView();
-			void refreshView(std::optional<Database::TrackArtistLinkType> linkType);
-			void addSomeArtists();
-			void addSomeReleases();
-			void addSomeTracks();
+        void refreshView();
+        void refreshView(std::optional<Database::TrackArtistLinkType> linkType);
+        void addSomeArtists();
+        void addSomeReleases();
+        void addSomeTracks();
 
-			PlayQueueController&	_playQueueController;
-			Filters&			_filters;
-			ArtistCollector		_artistCollector;
-			ReleaseCollector	_releaseCollector;
-			TrackCollector		_trackCollector;
+        PlayQueueController& _playQueueController;
+        Filters& _filters;
+        ArtistCollector		_artistCollector;
+        ReleaseCollector	_releaseCollector;
+        TrackCollector		_trackCollector;
+        Wt::WStackedWidget* _stack{};
+        Wt::WWidget*        _currentActiveItem {};
+        InfiniteScrollingContainer* _artists{};
+        InfiniteScrollingContainer* _releases{};
+        InfiniteScrollingContainer* _tracks{};
 
-			InfiniteScrollingContainer* _artists {};
-			InfiniteScrollingContainer* _releases {};
-			InfiniteScrollingContainer* _tracks {};
-
-			Wt::WComboBox* _artistLinkType {};
-
-			std::vector<InfiniteScrollingContainer*> _results;
-	};
+        Wt::WComboBox* _artistLinkType{};
+    };
 
 } // namespace UserInterface
 
diff --git a/src/lms/ui/explore/TrackCollector.cpp b/src/lms/ui/explore/TrackCollector.cpp
index ed6d2bd4..98e5b023 100644
--- a/src/lms/ui/explore/TrackCollector.cpp
+++ b/src/lms/ui/explore/TrackCollector.cpp
@@ -25,6 +25,7 @@
 #include "services/database/Track.hpp"
 #include "services/database/TrackList.hpp"
 #include "services/database/User.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "services/scrobbling/IScrobblingService.hpp"
 #include "utils/Service.hpp"
 #include "Filters.hpp"
@@ -32,101 +33,102 @@
 
 namespace UserInterface
 {
-	using namespace Database;
+    using namespace Database;
 
-	RangeResults<TrackId>
-	TrackCollector::get(Range range)
-	{
-		Scrobbling::IScrobblingService& scrobbling {*Service<Scrobbling::IScrobblingService>::get()};
-		range = getActualRange(range);
+    RangeResults<TrackId> TrackCollector::get(Range range)
+    {
+        Feedback::IFeedbackService& feedbackService{ *Service<Feedback::IFeedbackService>::get() };
+        Scrobbling::IScrobblingService& scrobblingService{ *Service<Scrobbling::IScrobblingService>::get() };
 
-		RangeResults<TrackId> tracks;
-		switch (getMode())
-		{
-			case Mode::Random:
-				tracks = getRandomTracks(range);
-				break;
+        RangeResults<TrackId> tracks;
+        range = getActualRange(range);
+        if (range.size == 0)
+            return tracks;
 
-			case Mode::Starred:
-				tracks = scrobbling.getStarredTracks(LmsApp->getUserId(), getFilters().getClusterIds(), range);
-				break;
+        switch (getMode())
+        {
+        case Mode::Random:
+            tracks = getRandomTracks(range);
+            break;
 
-			case TrackCollector::Mode::RecentlyPlayed:
-				tracks = scrobbling.getRecentTracks(LmsApp->getUserId(), getFilters().getClusterIds(), range);
-				break;
+        case Mode::Starred:
+            tracks = feedbackService.getStarredTracks(LmsApp->getUserId(), getFilters().getClusterIds(), range);
+            break;
 
-			case Mode::MostPlayed:
-				tracks = scrobbling.getTopTracks(LmsApp->getUserId(), getFilters().getClusterIds(), range);
-				break;
+        case TrackCollector::Mode::RecentlyPlayed:
+            tracks = scrobblingService.getRecentTracks(LmsApp->getUserId(), getFilters().getClusterIds(), range);
+            break;
 
-			case Mode::RecentlyAdded:
-			{
-				Track::FindParameters params;
-				params.setClusters(getFilters().getClusterIds());
-				params.setSortMethod(TrackSortMethod::LastWritten);
-				params.setRange(range);
+        case Mode::MostPlayed:
+            tracks = scrobblingService.getTopTracks(LmsApp->getUserId(), getFilters().getClusterIds(), range);
+            break;
 
-				{
-					auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-					tracks = Track::find(LmsApp->getDbSession(), params);
-				}
-				break;
-			}
+        case Mode::RecentlyAdded:
+        {
+            Track::FindParameters params;
+            params.setClusters(getFilters().getClusterIds());
+            params.setSortMethod(TrackSortMethod::LastWritten);
+            params.setRange(range);
 
-			case Mode::Search:
-			{
-				Track::FindParameters params;
-				params.setClusters(getFilters().getClusterIds());
-				params.setKeywords(getSearchKeywords());
-				params.setRange(range);
+            {
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                tracks = Track::findIds(LmsApp->getDbSession(), params);
+            }
+            break;
+        }
 
-				{
-					auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-					tracks = Track::find(LmsApp->getDbSession(), params);
-				}
-				break;
-			}
+        case Mode::Search:
+        {
+            Track::FindParameters params;
+            params.setClusters(getFilters().getClusterIds());
+            params.setKeywords(getSearchKeywords());
+            params.setRange(range);
 
-			case Mode::All:
-			{
-				Track::FindParameters params;
-				params.setClusters(getFilters().getClusterIds());
-				params.setRange(range);
+            {
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                tracks = Track::findIds(LmsApp->getDbSession(), params);
+            }
+            break;
+        }
 
-				{
-					auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-					tracks = Track::find(LmsApp->getDbSession(), params);
-				}
-				break;
-			}
-		}
+        case Mode::All:
+        {
+            Track::FindParameters params;
+            params.setClusters(getFilters().getClusterIds());
+            params.setRange(range);
 
-		if (range.offset + range.size == getMaxCount())
-			tracks.moreResults = false;
+            {
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                tracks = Track::findIds(LmsApp->getDbSession(), params);
+            }
+            break;
+        }
+        }
 
-		return tracks;
-	}
+        if (range.offset + range.size == getMaxCount())
+            tracks.moreResults = false;
 
-	RangeResults<TrackId>
-	TrackCollector::getRandomTracks(Range range)
-	{
-		assert(getMode() == Mode::Random);
+        return tracks;
+    }
 
-		if (!_randomTracks)
-		{
-			Track::FindParameters params;
-			params.setClusters(getFilters().getClusterIds());
-			params.setSortMethod(TrackSortMethod::Random);
-			params.setRange({0, getMaxCount()});
+    RangeResults<TrackId> TrackCollector::getRandomTracks(Range range)
+    {
+        assert(getMode() == Mode::Random);
 
-			{
-				auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-				_randomTracks = Track::find(LmsApp->getDbSession(), params);
-			}
-		}
+        if (!_randomTracks)
+        {
+            Track::FindParameters params;
+            params.setClusters(getFilters().getClusterIds());
+            params.setSortMethod(TrackSortMethod::Random);
+            params.setRange({ 0, getMaxCount() });
 
-		return _randomTracks->getSubRange(range);
-	}
+            {
+                auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+                _randomTracks = Track::findIds(LmsApp->getDbSession(), params);
+            }
+        }
+
+        return _randomTracks->getSubRange(range);
+    }
 
 } // ns UserInterface
-
diff --git a/src/lms/ui/explore/TrackListHelpers.cpp b/src/lms/ui/explore/TrackListHelpers.cpp
index 8ba46ad0..75cc4f68 100644
--- a/src/lms/ui/explore/TrackListHelpers.cpp
+++ b/src/lms/ui/explore/TrackListHelpers.cpp
@@ -30,7 +30,7 @@
 #include "services/database/Session.hpp"
 #include "services/database/Track.hpp"
 #include "services/database/TrackArtistLink.hpp"
-#include "services/scrobbling/IScrobblingService.hpp"
+#include "services/feedback/IFeedbackService.hpp"
 #include "utils/Logger.hpp"
 #include "utils/Service.hpp"
 
@@ -67,7 +67,7 @@ namespace UserInterface::TrackListHelpers
 			Artist::FindParameters params;
 			params.setTrack(trackId);
 			params.setLinkType(linkType);
-			const auto artistIds {Artist::find(LmsApp->getDbSession(), params)};
+			const auto artistIds {Artist::findIds(LmsApp->getDbSession(), params)};
 			if (artistIds.results.empty())
 				return;
 
@@ -167,7 +167,6 @@ namespace UserInterface::TrackListHelpers
 		const TrackId trackId {track->getId()};
 
 		const auto artists {track->getArtistIds({TrackArtistLinkType::Artist})};
-		LMS_LOG(UI, DEBUG) << "Found " << artists.size() << " artists!";
 		if (!artists.empty())
 		{
 			entry->setCondition("if-has-artists", true);
@@ -217,7 +216,7 @@ namespace UserInterface::TrackListHelpers
 			});
 
 		{
-			auto isStarred {[=] { return Service<Scrobbling::IScrobblingService>::get()->isStarred(LmsApp->getUserId(), trackId); }};
+			auto isStarred {[=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), trackId); }};
 
 			Wt::WPushButton* starBtn {entry->bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star"))};
 			starBtn->clicked().connect([=]
@@ -226,12 +225,12 @@ namespace UserInterface::TrackListHelpers
 
 				if (isStarred())
 				{
-					Service<Scrobbling::IScrobblingService>::get()->unstar(LmsApp->getUserId(), trackId);
+					Service<Feedback::IFeedbackService>::get()->unstar(LmsApp->getUserId(), trackId);
 					starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
 				}
 				else
 				{
-					Service<Scrobbling::IScrobblingService>::get()->star(LmsApp->getUserId(), trackId);
+					Service<Feedback::IFeedbackService>::get()->star(LmsApp->getUserId(), trackId);
 					starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
 				}
 			});
diff --git a/src/lms/ui/explore/TrackListView.cpp b/src/lms/ui/explore/TrackListView.cpp
index f7beb4bd..0774e2f0 100644
--- a/src/lms/ui/explore/TrackListView.cpp
+++ b/src/lms/ui/explore/TrackListView.cpp
@@ -39,166 +39,158 @@
 #include "ModalManager.hpp"
 #include "Utils.hpp"
 
-using namespace Database;
-
-namespace
-{
-	static
-	std::optional<TrackListId>
-	extractTrackListIdFromInternalPath()
-	{
-		return StringUtils::readAs<TrackListId::ValueType>(wApp->internalPathNextPart("/tracklist/"));
-	}
-}
-
 namespace UserInterface
 {
-	TrackList::TrackList(Filters& filters, PlayQueueController& playQueueController)
-	: Template {Wt::WString::tr("Lms.Explore.TrackList.template")}
-	, _filters {filters}
-	, _playQueueController {playQueueController}
-	{
-		addFunction("tr", &Wt::WTemplate::Functions::tr);
-		addFunction("id", &Wt::WTemplate::Functions::id);
+    using namespace Database;
 
-		wApp->internalPathChanged().connect(this, [this]
-		{
-			refreshView();
-		});
+    namespace
+    {
+        std::optional<TrackListId> extractTrackListIdFromInternalPath()
+        {
+            return StringUtils::readAs<TrackListId::ValueType>(wApp->internalPathNextPart("/tracklist/"));
+        }
+    }
 
-		_filters.updated().connect([this]
-		{
-			refreshView();
-		});
+    TrackList::TrackList(Filters& filters, PlayQueueController& playQueueController)
+        : Template{ Wt::WString::tr("Lms.Explore.TrackList.template") }
+        , _filters{ filters }
+        , _playQueueController{ playQueueController }
+    {
+        addFunction("tr", &Wt::WTemplate::Functions::tr);
+        addFunction("id", &Wt::WTemplate::Functions::id);
 
-		refreshView();
-	}
+        wApp->internalPathChanged().connect(this, [this]
+            {
+                refreshView();
+            });
 
-	void
-	TrackList::refreshView()
-	{
-		if (!wApp->internalPathMatches("/tracklist/"))
-			return;
+        _filters.updated().connect([this]
+            {
+                refreshView();
+            });
 
-		const std::optional<TrackListId> trackListId {extractTrackListIdFromInternalPath()};
-		if (!trackListId)
-			throw TrackListNotFoundException {};
+        refreshView();
+    }
 
-		auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+    void TrackList::refreshView()
+    {
+        if (!wApp->internalPathMatches("/tracklist/"))
+            return;
 
-		const Database::TrackList::pointer trackList {Database::TrackList::find(LmsApp->getDbSession(), *trackListId)};
-		if (!trackList)
-			throw TrackListNotFoundException {};
+        const std::optional<TrackListId> trackListId{ extractTrackListIdFromInternalPath() };
+        if (!trackListId)
+            throw TrackListNotFoundException{};
 
-		LmsApp->setTitle(std::string {trackList->getName()});
-		_trackListId = *trackListId;
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-		clear();
+        const Database::TrackList::pointer trackList{ Database::TrackList::find(LmsApp->getDbSession(), *trackListId) };
+        if (!trackList)
+            throw TrackListNotFoundException{};
 
-		bindString("name", std::string {trackList->getName()}, Wt::TextFormat::Plain);
-		bindString("duration", Utils::durationToString(trackList->getDuration()));
-		const auto trackCount {trackList->getCount()};
-		bindString("track-count", Wt::WString::trn("Lms.track-count", trackCount).arg(trackCount));
+        LmsApp->setTitle(std::string{ trackList->getName() });
+        _trackListId = *trackListId;
 
-		Wt::WContainerWidget* clusterContainers {bindNew<Wt::WContainerWidget>("clusters")};
-		{
-			const auto clusterTypes {ScanSettings::get(LmsApp->getDbSession())->getClusterTypes()};
-			const auto clusterGroups {trackList->getClusterGroups(clusterTypes, 3)};
+        clear();
 
-			for (const auto& clusters : clusterGroups)
-			{
-				for (const Database::Cluster::pointer& cluster : clusters)
-				{
-					const ClusterId clusterId {cluster->getId()};
-					Wt::WInteractWidget* entry {clusterContainers->addWidget(Utils::createCluster(clusterId))};
-					entry->clicked().connect([=]
-					{
-						_filters.add(clusterId);
-					});
-				}
-			}
-		}
+        bindString("name", std::string{ trackList->getName() }, Wt::TextFormat::Plain);
+        bindString("duration", Utils::durationToString(trackList->getDuration()));
+        const auto trackCount{ trackList->getCount() };
+        bindString("track-count", Wt::WString::trn("Lms.track-count", trackCount).arg(trackCount));
 
-		bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML)
-			->clicked().connect([=]
-			{
-				_playQueueController.processCommand(PlayQueueController::Command::Play, *trackListId);
-			});
+        Wt::WContainerWidget* clusterContainers{ bindNew<Wt::WContainerWidget>("clusters") };
+        {
+            const auto clusterTypes{ ScanSettings::get(LmsApp->getDbSession())->getClusterTypes() };
+            const auto clusterGroups{ trackList->getClusterGroups(clusterTypes, 3) };
 
-		bindNew<Wt::WPushButton>("play-shuffled", Wt::WString::tr("Lms.Explore.play-shuffled"), Wt::TextFormat::Plain)
-			->clicked().connect([=]
-			{
-				_playQueueController.processCommand(PlayQueueController::Command::PlayShuffled, *trackListId);
-			});
+            for (const auto& clusters : clusterGroups)
+            {
+                for (const Database::Cluster::pointer& cluster : clusters)
+                {
+                    const ClusterId clusterId{ cluster->getId() };
+                    Wt::WInteractWidget* entry{ clusterContainers->addWidget(Utils::createCluster(clusterId)) };
+                    entry->clicked().connect([=]
+                        {
+                            _filters.add(clusterId);
+                        });
+                }
+            }
+        }
 
-		bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"), Wt::TextFormat::Plain)
-			->clicked().connect([=]
-			{
-				_playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, *trackListId);
-			});
+        bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML)
+            ->clicked().connect([=]
+                {
+                    _playQueueController.processCommand(PlayQueueController::Command::Play, *trackListId);
+                });
 
-		bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
-			->setLink(Wt::WLink {std::make_unique<DownloadTrackListResource>(*trackListId)});
+        bindNew<Wt::WPushButton>("play-shuffled", Wt::WString::tr("Lms.Explore.play-shuffled"), Wt::TextFormat::Plain)
+            ->clicked().connect([=]
+                {
+                    _playQueueController.processCommand(PlayQueueController::Command::PlayShuffled, *trackListId);
+                });
 
-		bindNew<Wt::WPushButton>("delete", Wt::WString::tr("Lms.delete"))
-			->clicked().connect([=]
-			{
-				auto modal {std::make_unique<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.TrackList.template.delete-tracklist"))};
-				modal->addFunction("tr", &Wt::WTemplate::Functions::tr);
-				Wt::WWidget* modalPtr {modal.get()};
+        bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"), Wt::TextFormat::Plain)
+            ->clicked().connect([=]
+                {
+                    _playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, *trackListId);
+                });
 
-				auto* delBtn {modal->bindNew<Wt::WPushButton>("del-btn", Wt::WString::tr("Lms.delete"))};
-				delBtn->clicked().connect([=]
-				{
-					{
-						auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
+        bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
+            ->setLink(Wt::WLink{ std::make_unique<DownloadTrackListResource>(*trackListId) });
 
-						Database::TrackList::pointer trackList {Database::TrackList::find(LmsApp->getDbSession(), *trackListId)};
-						if (trackList)
-							trackList.remove();
-					}
+        bindNew<Wt::WPushButton>("delete", Wt::WString::tr("Lms.delete"))
+            ->clicked().connect([=]
+                {
+                    auto modal{ std::make_unique<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.TrackList.template.delete-tracklist")) };
+                    modal->addFunction("tr", &Wt::WTemplate::Functions::tr);
+                    Wt::WWidget* modalPtr{ modal.get() };
 
-					clear();
-					trackListDeleted.emit(*trackListId);
-					LmsApp->setInternalPath("/tracklists", true);
+                    auto* delBtn{ modal->bindNew<Wt::WPushButton>("del-btn", Wt::WString::tr("Lms.delete")) };
+                    delBtn->clicked().connect([=]
+                        {
+                            {
+                                auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
 
-					LmsApp->getModalManager().dispose(modalPtr);
-				});
+                                Database::TrackList::pointer trackList{ Database::TrackList::find(LmsApp->getDbSession(), *trackListId) };
+                                if (trackList)
+                                    trackList.remove();
+                            }
 
-				auto* cancelBtn {modal->bindNew<Wt::WPushButton>("cancel-btn", Wt::WString::tr("Lms.cancel"))};
-				cancelBtn->clicked().connect([=]
-				{
-					LmsApp->getModalManager().dispose(modalPtr);
-				});
+                            clear();
+                            trackListDeleted.emit(*trackListId);
+                            LmsApp->setInternalPath("/tracklists", true);
 
-				LmsApp->getModalManager().show(std::move(modal));
-			});
+                            LmsApp->getModalManager().dispose(modalPtr);
+                        });
 
-		_container = bindNew<InfiniteScrollingContainer>("tracks", Wt::WString::tr("Lms.Explore.TrackList.template.entry-container"));
-		_container->onRequestElements.connect([this]
-		{
-			addSome();
-		});
-	}
+                    auto* cancelBtn{ modal->bindNew<Wt::WPushButton>("cancel-btn", Wt::WString::tr("Lms.cancel")) };
+                    cancelBtn->clicked().connect([=]
+                        {
+                            LmsApp->getModalManager().dispose(modalPtr);
+                        });
 
-	void
-	TrackList::addSome()
-	{
-		auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+                    LmsApp->getModalManager().show(std::move(modal));
+                });
 
-		Database::Track::FindParameters params;
-		params.setClusters(_filters.getClusterIds());
-		params.setTrackList(_trackListId);
-		params.setSortMethod(Database::TrackSortMethod::TrackList);
-		params.setRange({static_cast<std::size_t>(_container->getCount()), _batchSize});
-		params.setDistinct(false);
+        _container = bindNew<InfiniteScrollingContainer>("tracks", Wt::WString::tr("Lms.Explore.TrackList.template.entry-container"));
+        _container->onRequestElements.connect([this]
+            {
+                addSome();
+            });
+    }
 
-		const auto trackIds {Database::Track::find(LmsApp->getDbSession(), params)};
-		for (const TrackId trackId : trackIds.results)
-		{
-			if (const Track::pointer track {Track::find(LmsApp->getDbSession(), trackId)})
-				_container->add(TrackListHelpers::createEntry(track, _playQueueController, _filters));
-		}
-	}
+    void TrackList::addSome()
+    {
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
+
+        Database::Track::FindParameters params;
+        params.setClusters(_filters.getClusterIds());
+        params.setTrackList(_trackListId);
+        params.setSortMethod(Database::TrackSortMethod::TrackList);
+        params.setRange({ static_cast<std::size_t>(_container->getCount()), _batchSize });
+        params.setDistinct(false);
+
+        for (const Track::pointer& track : Database::Track::find(LmsApp->getDbSession(), params).results)
+            _container->add(TrackListHelpers::createEntry(track, _playQueueController, _filters));
+    }
 } // namespace UserInterface
 
diff --git a/src/lms/ui/resource/DownloadResource.cpp b/src/lms/ui/resource/DownloadResource.cpp
index 594c8182..42138fb6 100644
--- a/src/lms/ui/resource/DownloadResource.cpp
+++ b/src/lms/ui/resource/DownloadResource.cpp
@@ -19,10 +19,6 @@
 
 #include "DownloadResource.hpp"
 
-#include <array>
-#include <iostream>
-#include <iomanip>
-
 #include <Wt/Http/Response.h>
 #include <Wt/WDateTime.h>
 
@@ -38,243 +34,214 @@
 
 #define LOG(level)	LMS_LOG(UI, level) << "Download resource: "
 
-namespace UserInterface {
-
-DownloadResource::~DownloadResource()
+namespace UserInterface
 {
-	beingDeleted();
-}
 
-void
-DownloadResource::handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response)
-{
-	try
-	{
-		std::shared_ptr<Zip::IZipper> zipper;
+    DownloadResource::~DownloadResource()
+    {
+        beingDeleted();
+    }
 
-		// First, see if this request is for a continuation
-		if (Wt::Http::ResponseContinuation *continuation {request.continuation()})
-			zipper = Wt::cpp17::any_cast<std::shared_ptr<Zip::IZipper>>(continuation->data());
-		else
-		{
-			zipper = createZipper();
-			response.setMimeType("application/zip");
-		}
+    void DownloadResource::handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response)
+    {
+        try
+        {
+            std::shared_ptr<Zip::IZipper> zipper;
 
-		zipper->writeSome(response.out());
-		if (!zipper->isComplete())
-		{
-			auto* continuation {response.createContinuation()};
-			continuation->setData(zipper);
-		}
-	}
-	catch (Zip::Exception& exception)
-	{
-		LOG(ERROR) << "Zipper exception: " << exception.what();
-	}
-}
+            // First, see if this request is for a continuation
+            if (Wt::Http::ResponseContinuation * continuation{ request.continuation() })
+                zipper = Wt::cpp17::any_cast<std::shared_ptr<Zip::IZipper>>(continuation->data());
+            else
+            {
+                zipper = createZipper();
+                response.setMimeType("application/zip");
+            }
 
-static
-std::string
-getArtistPathName(Database::Artist::pointer artist)
-{
-	return StringUtils::replaceInString(artist->getName(), "/", "_");
-}
+            zipper->writeSome(response.out());
+            if (!zipper->isComplete())
+            {
+                auto* continuation{ response.createContinuation() };
+                continuation->setData(zipper);
+            }
+        }
+        catch (Zip::Exception& exception)
+        {
+            LOG(ERROR) << "Zipper exception: " << exception.what();
+        }
+    }
 
-static
-std::string
-getReleaseArtistPathName(Database::Release::pointer release)
-{
-	std::string releaseArtistName;
+    namespace
+    {
+        std::string getArtistPathName(Database::Artist::pointer artist)
+        {
+            return StringUtils::replaceInString(artist->getName(), "/", "_");
+        }
 
-	std::vector<Database::ObjectPtr<Database::Artist>> artists;
+        std::string getReleaseArtistPathName(Database::Release::pointer release)
+        {
+            std::string releaseArtistName;
 
-	artists = release->getReleaseArtists();
-	if (artists.empty())
-		artists = release->getArtists();
+            std::vector<Database::ObjectPtr<Database::Artist>> artists;
 
-	if (artists.size() > 1)
-		releaseArtistName = Wt::WString::tr("Lms.Explore.various-artists").toUTF8();
-	else if (artists.size() == 1)
-		releaseArtistName = artists.front()->getName();
+            artists = release->getReleaseArtists();
+            if (artists.empty())
+                artists = release->getArtists();
 
-	releaseArtistName = StringUtils::replaceInString(releaseArtistName, "/", "_");
+            if (artists.size() > 1)
+                releaseArtistName = Wt::WString::tr("Lms.Explore.various-artists").toUTF8();
+            else if (artists.size() == 1)
+                releaseArtistName = artists.front()->getName();
 
-	return releaseArtistName;
-}
+            releaseArtistName = StringUtils::replaceInString(releaseArtistName, "/", "_");
 
-static
-std::string
-getReleasePathName(Database::Release::pointer release)
-{
-	std::string releaseName;
+            return releaseArtistName;
+        }
 
-	if (const Wt::WDate releaseDate {release->getReleaseDate()}; releaseDate.isValid())
-		releaseName += std::to_string(releaseDate.year()) + " - ";
-	releaseName += StringUtils::replaceInString(release->getName(), "/", "_");
+        std::string getReleasePathName(Database::Release::pointer release)
+        {
+            std::string releaseName;
 
-	return releaseName;
-}
+            if (const Wt::WDate releaseDate{ release->getReleaseDate() }; releaseDate.isValid())
+                releaseName += std::to_string(releaseDate.year()) + " - ";
+            releaseName += StringUtils::replaceInString(release->getName(), "/", "_");
 
-namespace details
-{
-	static
-	std::string
-	getTrackPathName(Database::Track::pointer track)
-	{
-		std::ostringstream fileName;
+            return releaseName;
+        }
+    }
 
-		if (auto discNumber {track->getDiscNumber()})
-			fileName << *discNumber << ".";
-		if (auto trackNumber {track->getTrackNumber()})
-			fileName << std::setw(2) << std::setfill('0') << *trackNumber << " - ";
+    namespace details
+    {
+        std::string getTrackPathName(Database::Track::pointer track)
+        {
+            std::ostringstream fileName;
 
-		fileName << StringUtils::replaceInString(track->getName(), "/", "_") << track->getPath().filename().extension().string();
+            if (auto discNumber{ track->getDiscNumber() })
+                fileName << *discNumber << ".";
+            if (auto trackNumber{ track->getTrackNumber() })
+                fileName << std::setw(2) << std::setfill('0') << *trackNumber << " - ";
 
-		return fileName.str();
-	}
+            fileName << StringUtils::replaceInString(track->getName(), "/", "_") << track->getPath().filename().extension().string();
 
-	static
-	std::string
-	getTrackListPathName(Database::TrackList::pointer trackList)
-	{
-		return StringUtils::replaceInString(trackList->getName(), "/", "_");
-	}
+            return fileName.str();
+        }
 
-	static
-	std::unique_ptr<Zip::IZipper>
-	createZipper(const std::vector<Database::Track::pointer>& tracks)
-	{
-		if (tracks.empty())
-			return {};
+        std::string getTrackListPathName(Database::TrackList::pointer trackList)
+        {
+            return StringUtils::replaceInString(trackList->getName(), "/", "_");
+        }
 
-		Zip::EntryContainer files;
-		for (const Database::Track::pointer& track : tracks)
-		{
-			std::string releaseName;
-			std::string releaseArtistName;
-			if (auto release {track->getRelease()})
-			{
-				releaseName = getReleasePathName(release);
-				releaseArtistName = getReleaseArtistPathName(release);
-			}
+        std::unique_ptr<Zip::IZipper> createZipper(const std::vector<Database::Track::pointer>& tracks)
+        {
+            if (tracks.empty())
+                return {};
 
-			std::string fileName;
-			if (!releaseArtistName.empty())
-				fileName += releaseArtistName + "/";
-			if (!releaseName.empty())
-				fileName += releaseName + "/";
-			fileName += getTrackPathName(track);
+            Zip::EntryContainer files;
+            for (const Database::Track::pointer& track : tracks)
+            {
+                std::string releaseName;
+                std::string releaseArtistName;
+                if (auto release{ track->getRelease() })
+                {
+                    releaseName = getReleasePathName(release);
+                    releaseArtistName = getReleaseArtistPathName(release);
+                }
 
-			files.emplace_back(Zip::Entry {fileName, track->getPath()});
-		}
+                std::string fileName;
+                if (!releaseArtistName.empty())
+                    fileName += releaseArtistName + "/";
+                if (!releaseName.empty())
+                    fileName += releaseName + "/";
+                fileName += getTrackPathName(track);
 
-		return Zip::createArchiveZipper(files);
-	}
-}
+                files.emplace_back(Zip::Entry{ fileName, track->getPath() });
+            }
 
-DownloadArtistResource::DownloadArtistResource(Database::ArtistId artistId)
-: _artistId {artistId}
-{
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+            return Zip::createArchiveZipper(files);
+        }
+    }
 
-	Database::Artist::pointer artist {Database::Artist::find(LmsApp->getDbSession(), artistId)};
-	if (artist)
-		suggestFileName(getArtistPathName(artist) + ".zip");
-}
+    DownloadArtistResource::DownloadArtistResource(Database::ArtistId artistId)
+        : _artistId{ artistId }
+    {
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-std::unique_ptr<Zip::IZipper>
-DownloadArtistResource::createZipper()
-{
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+        Database::Artist::pointer artist{ Database::Artist::find(LmsApp->getDbSession(), artistId) };
+        if (artist)
+            suggestFileName(getArtistPathName(artist) + ".zip");
+    }
 
-	const auto trackResults {Database::Track::find(LmsApp->getDbSession(), Database::Track::FindParameters {}.setArtist(_artistId).setSortMethod(Database::TrackSortMethod::DateDescAndRelease))};
-	std::vector<Database::Track::pointer> tracks;
-	tracks.reserve(trackResults.results.size());
+    std::unique_ptr<Zip::IZipper> DownloadArtistResource::createZipper()
+    {
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-	for (const Database::TrackId trackId : trackResults.results)
-		tracks.push_back(Database::Track::find(LmsApp->getDbSession(), trackId));
+        const auto trackResults{ Database::Track::find(LmsApp->getDbSession(), Database::Track::FindParameters {}.setArtist(_artistId).setSortMethod(Database::TrackSortMethod::DateDescAndRelease)) };
+        return details::createZipper(trackResults.results);
+    }
 
-	return details::createZipper(tracks);
-}
+    DownloadReleaseResource::DownloadReleaseResource(Database::ReleaseId releaseId)
+        : _releaseId{ releaseId }
+    {
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-DownloadReleaseResource::DownloadReleaseResource(Database::ReleaseId releaseId)
-: _releaseId {releaseId}
-{
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-
-	Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), releaseId)};
-	if (release)
-		suggestFileName(getReleasePathName(release) + ".zip");
-}
+        Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), releaseId) };
+        if (release)
+            suggestFileName(getReleasePathName(release) + ".zip");
+    }
 
 
-std::unique_ptr<Zip::IZipper>
-DownloadReleaseResource::createZipper()
-{
-	using namespace Database;
+    std::unique_ptr<Zip::IZipper> DownloadReleaseResource::createZipper()
+    {
+        using namespace Database;
 
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-	auto trackResults {Track::find(LmsApp->getDbSession(), Track::FindParameters {}.setRelease(_releaseId).setSortMethod(TrackSortMethod::Release))};
+        auto tracks{ Track::find(LmsApp->getDbSession(), Track::FindParameters {}.setRelease(_releaseId).setSortMethod(TrackSortMethod::Release)) };
+        return details::createZipper(tracks.results);
+    }
 
-	std::vector<Track::pointer> tracks;
-	tracks.reserve(trackResults.results.size());
-	std::transform(std::cbegin(trackResults.results), std::cend(trackResults.results), std::back_inserter(tracks), [](TrackId trackId){ return Track::find(LmsApp->getDbSession(), trackId); });
+    DownloadTrackResource::DownloadTrackResource(Database::TrackId trackId)
+        : _trackId{ trackId }
+    {
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-	return details::createZipper(tracks);
-}
+        Database::Track::pointer track{ Database::Track::find(LmsApp->getDbSession(), trackId) };
+        if (track)
+            suggestFileName(details::getTrackPathName(track) + ".zip");
+    }
 
-DownloadTrackResource::DownloadTrackResource(Database::TrackId trackId)
-: _trackId {trackId}
-{
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+    std::unique_ptr<Zip::IZipper> DownloadTrackResource::createZipper()
+    {
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-	Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), trackId)};
-	if (track)
-		suggestFileName(details::getTrackPathName(track) + ".zip");
-}
+        const Database::Track::pointer track{ Database::Track::find(LmsApp->getDbSession(), _trackId) };
+        if (!track)
+        {
+            LOG(DEBUG) << "Cannot find track";
+            return {};
+        }
 
-std::unique_ptr<Zip::IZipper>
-DownloadTrackResource::createZipper()
-{
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+        return details::createZipper({ track });
+    }
 
-	const Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), _trackId)};
-	if (!track)
-	{
-		LOG(DEBUG) << "Cannot find track";
-		return {};
-	}
+    DownloadTrackListResource::DownloadTrackListResource(Database::TrackListId trackListId)
+        : _trackListId{ trackListId }
+    {
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-	return details::createZipper({track});
-}
+        const Database::TrackList::pointer trackList{ Database::TrackList::find(LmsApp->getDbSession(), trackListId) };
+        if (trackList)
+            suggestFileName(details::getTrackListPathName(trackList) + ".zip");
+    }
 
-DownloadTrackListResource::DownloadTrackListResource(Database::TrackListId trackListId)
-	: _trackListId {trackListId}
-{
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+    std::unique_ptr<Zip::IZipper> DownloadTrackListResource::createZipper()
+    {
+        using namespace Database;
+        auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
 
-	const Database::TrackList::pointer trackList {Database::TrackList::find(LmsApp->getDbSession(), trackListId)};
-	if (trackList)
-		suggestFileName(details::getTrackListPathName(trackList) + ".zip");
-}
-
-std::unique_ptr<Zip::IZipper>
-DownloadTrackListResource::createZipper()
-{
-	using namespace Database;
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
-
-	Track::FindParameters params;
-	params.setTrackList(_trackListId);
-	const auto trackResults {Track::find(LmsApp->getDbSession(), params)};
-
-	std::vector<Track::pointer> tracks;
-	tracks.reserve(trackResults.results.size());
-	std::transform(std::cbegin(trackResults.results), std::cend(trackResults.results), std::back_inserter(tracks), [](TrackId trackId){ return Track::find(LmsApp->getDbSession(), trackId); });
-
-	return details::createZipper(tracks);
-}
+        Track::FindParameters params;
+        params.setTrackList(_trackListId);
+        const auto tracks{ Track::find(LmsApp->getDbSession(), params) };
+        return details::createZipper(tracks.results);
+    }
 
 } // namespace UserInterface
diff --git a/src/tools/cover/LmsCover.cpp b/src/tools/cover/LmsCover.cpp
index 36291e5b..c90149ed 100644
--- a/src/tools/cover/LmsCover.cpp
+++ b/src/tools/cover/LmsCover.cpp
@@ -43,7 +43,7 @@ dumpTrackCovers(Database::Session& session, Image::ImageSize width)
 	RangeResults<Database::TrackId> trackIds;
 	{
 		auto transaction {session.createSharedTransaction()};
-		trackIds = Database::Track::find(session, Database::Track::FindParameters {});
+		trackIds = Database::Track::findIds(session, Database::Track::FindParameters {});
 	}
 
 	for (const Database::TrackId trackId : trackIds.results)
diff --git a/src/tools/recommendation/LmsRecommendation.cpp b/src/tools/recommendation/LmsRecommendation.cpp
index 5dec1cb3..33d73d6c 100644
--- a/src/tools/recommendation/LmsRecommendation.cpp
+++ b/src/tools/recommendation/LmsRecommendation.cpp
@@ -38,158 +38,151 @@
 
 using namespace Database;
 
-static
-void
-dumpTracksRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
+static void dumpTracksRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
 {
-	const RangeResults<TrackId> trackIds {[&]()
-		{
-			auto transaction {session.createSharedTransaction()};
-			return Track::find(session, Track::FindParameters {});
-		}()};
+    const RangeResults<TrackId> trackIds{ [&]
+        {
+            auto transaction {session.createSharedTransaction()};
+            return Track::findIds(session, Track::FindParameters{});
+        }() };
 
-	std::cout << "*** Tracks (" << trackIds.results.size() << ") ***" << std::endl;
-	for (const TrackId trackId : trackIds.results)
-	{
-		auto trackToString = [&](const TrackId trackId)
-		{
-			std::string res;
-			auto transaction {session.createSharedTransaction()};
-			const Track::pointer track {Track::find(session, trackId)};
+    std::cout << "*** Tracks (" << trackIds.results.size() << ") ***" << std::endl;
+    for (const TrackId trackId : trackIds.results)
+    {
+        auto trackToString = [&](const TrackId trackId)
+            {
+                std::string res;
+                auto transaction{ session.createSharedTransaction() };
+                const Track::pointer track{ Track::find(session, trackId) };
 
-			res += track->getName();
-			if (track->getRelease())
-				res += " [" + track->getRelease()->getName() + "]";
-			for (auto artist : track->getArtists({TrackArtistLinkType::Artist}))
-				res += " - " + artist->getName();
-			for (auto cluster : track->getClusters())
-				res += " {" + cluster->getType()->getName() + "-"+ cluster->getName() + "}";
+                res += track->getName();
+                if (track->getRelease())
+                    res += " [" + track->getRelease()->getName() + "]";
+                for (auto artist : track->getArtists({ TrackArtistLinkType::Artist }))
+                    res += " - " + artist->getName();
+                for (auto cluster : track->getClusters())
+                    res += " {" + cluster->getType()->getName() + "-" + cluster->getName() + "}";
 
-			return res;
-		};
+                return res;
+            };
 
-		std::cout << "Processing track '" << trackToString(trackId) << std::endl;
-		for (TrackId similarTrackId : recommendationService.findSimilarTracks({trackId}, maxSimilarityCount))
-			std::cout << "\t- Similar track '" << trackToString(similarTrackId) << std::endl;
-	}
+        std::cout << "Processing track '" << trackToString(trackId) << std::endl;
+        for (TrackId similarTrackId : recommendationService.findSimilarTracks({ trackId }, maxSimilarityCount))
+            std::cout << "\t- Similar track '" << trackToString(similarTrackId) << std::endl;
+    }
 }
 
-static
-void
-dumpReleasesRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
+static void dumpReleasesRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
 {
-	const RangeResults<ReleaseId> releaseIds {std::invoke([&]()
-		{
-			auto transaction {session.createSharedTransaction()};
-			return Release::find(session, Release::FindParameters {});
-		})};
+    const RangeResults<ReleaseId> releaseIds{ std::invoke([&]
+        {
+            auto transaction {session.createSharedTransaction()};
+            return Release::findIds(session, Release::FindParameters {});
+        }) };
 
-	std::cout << "*** Releases ***" << std::endl;
-	for (ReleaseId releaseId : releaseIds.results)
-	{
-		auto releaseToString = [&](ReleaseId releaseId) -> std::string
-		{
-			auto transaction {session.createSharedTransaction()};
+    std::cout << "*** Releases ***" << std::endl;
+    for (const ReleaseId releaseId : releaseIds.results)
+    {
+        auto releaseToString = [&](ReleaseId releaseId) -> std::string
+            {
+                auto transaction{ session.createSharedTransaction() };
 
-			Release::pointer release {Release::find(session, releaseId)};
-			return release->getName();
-		};
+                Release::pointer release{ Release::find(session, releaseId) };
+                return release->getName();
+            };
 
-		std::cout << "Processing release '" << releaseToString(releaseId) << "'" << std::endl;
-		for (ReleaseId similarReleaseId : recommendationService.getSimilarReleases(releaseId, maxSimilarityCount))
-			std::cout << "\t- Similar release '" << releaseToString(similarReleaseId) << "'" << std::endl;
-	}
+        std::cout << "Processing release '" << releaseToString(releaseId) << "'" << std::endl;
+        for (const ReleaseId similarReleaseId : recommendationService.getSimilarReleases(releaseId, maxSimilarityCount))
+            std::cout << "\t- Similar release '" << releaseToString(similarReleaseId) << "'" << std::endl;
+    }
 }
 
-static
-void
-dumpArtistsRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
+static void dumpArtistsRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
 {
-	const RangeResults<ArtistId> artistIds = std::invoke([&]()
-	{
-		auto transaction {session.createSharedTransaction()};
-		return Artist::find(session, Artist::FindParameters {});
-	});
+    const RangeResults<ArtistId> artistIds = std::invoke([&]()
+        {
+            auto transaction{ session.createSharedTransaction() };
+            return Artist::findIds(session, Artist::FindParameters{});
+        });
 
-	std::cout << "*** Artists ***" << std::endl;
-	for (ArtistId artistId : artistIds.results)
-	{
-		auto artistToString = [&](ArtistId artistId)
-		{
-			auto transaction {session.createSharedTransaction()};
+    std::cout << "*** Artists ***" << std::endl;
+    for (ArtistId artistId : artistIds.results)
+    {
+        auto artistToString = [&](ArtistId artistId)
+            {
+                auto transaction{ session.createSharedTransaction() };
 
-			Artist::pointer artist {Artist::find(session, artistId)};
-			return artist->getName();
-		};
+                Artist::pointer artist{ Artist::find(session, artistId) };
+                return artist->getName();
+            };
 
-		std::cout << "Processing artist '" << artistToString(artistId) << "'" << std::endl;
-		for (ArtistId similarArtistId : recommendationService.getSimilarArtists(artistId, {TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist}, maxSimilarityCount))
-		{
-			std::cout << "\t- Similar artist '" << artistToString(similarArtistId) << "'" << std::endl;
-		}
-	}
+        std::cout << "Processing artist '" << artistToString(artistId) << "'" << std::endl;
+        for (ArtistId similarArtistId : recommendationService.getSimilarArtists(artistId, { TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist }, maxSimilarityCount))
+        {
+            std::cout << "\t- Similar artist '" << artistToString(similarArtistId) << "'" << std::endl;
+        }
+    }
 }
 
-
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
-	try
-	{
-		namespace po = boost::program_options;
+    try
+    {
+        namespace po = boost::program_options;
 
-		// log to stdout
-		Service<Logger> logger {std::make_unique<StreamLogger>(std::cout)};
+        // log to stdout
+        Service<Logger> logger{ std::make_unique<StreamLogger>(std::cout) };
 
-		po::options_description desc{"Allowed options"};
+        po::options_description desc{ "Allowed options" };
         desc.add_options()
-        ("help,h", "print usage message")
-		("conf,c", po::value<std::string>()->default_value("/etc/lms.conf"), "LMS config file")
-        ("artists,a", "Display recommendation for artists")
-        ("releases,r", "Display recommendation for releases")
-        ("tracks,t", "Display recommendation for tracks")
-		("max,m", po::value<unsigned>()->default_value(3), "Max similarity result count")
-        ;
+            ("help,h", "print usage message")
+            ("conf,c", po::value<std::string>()->default_value("/etc/lms.conf"), "LMS config file")
+            ("artists,a", "Display recommendation for artists")
+            ("releases,r", "Display recommendation for releases")
+            ("tracks,t", "Display recommendation for tracks")
+            ("max,m", po::value<unsigned>()->default_value(3), "Max similarity result count")
+            ;
 
         po::variables_map vm;
         po::store(po::parse_command_line(argc, argv, desc), vm);
 
         if (vm.count("help"))
-		{
-			std::cout << desc << std::endl;
+        {
+            std::cout << desc << std::endl;
             return EXIT_SUCCESS;
         }
 
-		Service<IConfig> config {createConfig(vm["conf"].as<std::string>())};
+        Service<IConfig> config{ createConfig(vm["conf"].as<std::string>()) };
 
-		Db db {config->getPath("working-dir") / "lms.db"};
-		Session session {db};
+        Db db{ config->getPath("working-dir") / "lms.db" };
+        Session session{ db };
 
-		std::cout << "Creating recommendation recommendationService..." << std::endl;
-		const auto recommendationService {Recommendation::createRecommendationService(db)};
-		std::cout << "Recommendation recommendationService created!" << std::endl;
+        std::cout << "Creating recommendation recommendationService..." << std::endl;
+        const auto recommendationService{ Recommendation::createRecommendationService(db) };
+        std::cout << "Recommendation recommendationService created!" << std::endl;
 
-		std::cout << "Loading recommendation recommendationService..." << std::endl;
-		recommendationService->load(false);
+        std::cout << "Loading recommendation recommendationService..." << std::endl;
+        recommendationService->load(false);
 
-		unsigned maxSimilarityCount {vm["max"].as<unsigned>()};
+        unsigned maxSimilarityCount{ vm["max"].as<unsigned>() };
 
-		std::cout << "Recommendation recommendationService loaded!" << std::endl;
+        std::cout << "Recommendation recommendationService loaded!" << std::endl;
 
-		if (vm.count("tracks"))
-			dumpTracksRecommendation(db, *recommendationService, maxSimilarityCount);
+        if (vm.count("tracks"))
+            dumpTracksRecommendation(db, *recommendationService, maxSimilarityCount);
 
-		if (vm.count("releases"))
-			dumpReleasesRecommendation(db, *recommendationService, maxSimilarityCount);
+        if (vm.count("releases"))
+            dumpReleasesRecommendation(db, *recommendationService, maxSimilarityCount);
 
-		if (vm.count("artists"))
-			dumpArtistsRecommendation(db, *recommendationService, maxSimilarityCount);
-	}
-	catch( std::exception& e)
-	{
-		std::cerr << "Caught exception: " << e.what() << std::endl;
-		return EXIT_FAILURE;
-	}
+        if (vm.count("artists"))
+            dumpArtistsRecommendation(db, *recommendationService, maxSimilarityCount);
+    }
+    catch (std::exception& e)
+    {
+        std::cerr << "Caught exception: " << e.what() << std::endl;
+        return EXIT_FAILURE;
+    }
 
-	return EXIT_SUCCESS;
+    return EXIT_SUCCESS;
 }