Databsae service refactoring. Warning, loses stars and listens stats

src/libs/services/scrobbling/impl/IScrobbler.hpp

@@ -23,8 +23,9 @@
 #include <memory>
 #include <optional>
 
-#include <Wt/WDateTime.h>
-
+#include "services/database/ArtistId.hpp"
+#include "services/database/ReleaseId.hpp"
+#include "services/database/TrackListId.hpp"
 #include "services/scrobbling/Listen.hpp"
 
 namespace Database
@@ -36,18 +37,26 @@ namespace Database
 
 namespace Scrobbling
 {
-
 	class IScrobbler
 	{
 		public:
 			virtual ~IScrobbler() = 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;
 
-			virtual Database::ObjectPtr<Database::TrackList> getListensTrackList(Database::Session& session, Database::ObjectPtr<Database::User> user)  = 0;
+			// Feedback
+ 			virtual void onStarred(Database::UserId, Database::ArtistId) {};
+ 			virtual void onUnstarred(Database::UserId, Database::ArtistId) {};
+ 			virtual void onStarred(Database::UserId, Database::ReleaseId) {};
+ 			virtual void onUnstarred(Database::UserId, Database::ReleaseId) {};
+ 			virtual void onStarred(Database::UserId, Database::TrackId) {};
+ 			virtual void onUnstarred(Database::UserId, Database::TrackId) {};
+
+//			virtual void star(Database::TrackId trackId) = 0;
+//			virtual void unstar(Database::TrackId trackId) = 0;
 	};
 
 	std::unique_ptr<IScrobbler> createScrobbler(std::string_view backendName);

src/libs/services/scrobbling/impl/ScrobblerBase.cpp

@@ -0,0 +1,72 @@
+/*
+ * 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_view>
+#include "services/scrobbling/Listen.hpp"
+
+namespace Scrobbling
+{
+	ScrobblerBase::ScrobblerBase(Database::Db& db)
+		: _db {db}
+	{
+	}
+
+	Database::TrackListId
+	ScrobberBase::getListensTrackList(Database::UserId userId, std::string_view trackListName)
+	{
+		std::string_view listensTrackListName {getListensTrackListName()};
+		Database::Session& session {_db.getTLSSession()};
+
+		{
+			auto transaction {session.createSharedTransaction()};
+
+			if (auto trackList {Database::TrackList::get(session, listensTrackListName, Database::TrackList::Type::Internal, userId)})
+				return trackList->getId();
+		}
+
+		{
+			auto transaction {session.createUniqueTransaction()};
+			if (auto trackList {Database::TrackList::get(session, listensTrackListName, Database::TrackList::Type::Internal, userId)})
+				return trackList->getId();
+
+			const Database::User::pointer user {Database::User::getById(session, userId)};
+			if (!user)
+				return {};
+
+			Database::TrackList::pointer trackList {Database::TrackList::create(session, listensTrackListName, Database::TrackList::Type::Internal, false, user)};
+			return trackList->getId();
+		}
+	}
+
+	bool
+	ScrobberBase::saveTimedListen(const TimedListen& listen, std::string_view trackListName)
+	{
+		const Database::TrackListId trackListId {getListensTrackList(listen.userId)};
+		if (!trackListId)
+			return false;
+
+		{
+
+			return true;
+		}
+	}
+} // ns Scrobbling
+

src/libs/services/scrobbling/impl/ScrobblingService.cpp

@@ -18,13 +18,17 @@
  */
 
 #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/TrackList.hpp"
 #include "services/database/User.hpp"
 
 #include "internal/InternalScrobbler.hpp"
@@ -43,202 +47,248 @@ namespace Scrobbling
 	ScrobblingService::ScrobblingService(boost::asio::io_context& ioContext, Db& db)
 		: _db {db}
 	{
-		_scrobblers.emplace(Database::Scrobbler::Internal, std::make_unique<InternalScrobbler>(_db));
-		_scrobblers.emplace(Database::Scrobbler::ListenBrainz, std::make_unique<ListenBrainz::Scrobbler>(ioContext, _db));
+		_scrobblers.emplace(Scrobbler::Internal, std::make_unique<InternalScrobbler>(_db));
+		_scrobblers.emplace(Scrobbler::ListenBrainz, std::make_unique<ListenBrainz::Scrobbler>(ioContext, _db));
 	}
 
 	void
 	ScrobblingService::listenStarted(const Listen& listen)
 	{
-		if (std::optional<Database::Scrobbler> scrobbler {getUserScrobbler(listen.userId)})
+		if (std::optional<Scrobbler> scrobbler {getUserScrobbler(listen.userId)})
 			_scrobblers[*scrobbler]->listenStarted(listen);
 	}
 
 	void
 	ScrobblingService::listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration)
 	{
-		if (std::optional<Database::Scrobbler> scrobbler {getUserScrobbler(listen.userId)})
+		if (std::optional<Scrobbler> scrobbler {getUserScrobbler(listen.userId)})
 			_scrobblers[*scrobbler]->listenFinished(listen, duration);
 	}
 
 	void
 	ScrobblingService::addTimedListen(const TimedListen& listen)
 	{
-		if (std::optional<Database::Scrobbler> scrobbler {getUserScrobbler(listen.userId)})
+		if (std::optional<Scrobbler> scrobbler {getUserScrobbler(listen.userId)})
 			_scrobblers[*scrobbler]->addTimedListen(listen);
 	}
 
-	std::optional<Database::Scrobbler>
-	ScrobblingService::getUserScrobbler(Database::UserId userId)
+	std::optional<Scrobbler>
+	ScrobblingService::getUserScrobbler(UserId userId)
 	{
-		std::optional<Database::Scrobbler> scrobbler;
+		std::optional<Scrobbler> scrobbler;
 
 		Session& session {_db.getTLSSession()};
 		auto transaction {session.createSharedTransaction()};
-		if (const User::pointer user {User::getById(session, userId)})
+		if (const User::pointer user {User::find(session, userId)})
 			scrobbler = user->getScrobbler();
 
 		return scrobbler;
 	}
 
 	ScrobblingService::ArtistContainer
-	ScrobblingService::getRecentArtists(UserId userId,
-									const std::vector<ClusterId>& clusterIds,
-									std::optional<TrackArtistLinkType> linkType,
-									std::optional<Range> range,
-									bool& moreResults)
+	ScrobblingService::getRecentArtists(UserId userId, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, Range range)
 	{
 		ArtistContainer res;
 
+		auto scrobbler {getUserScrobbler(userId)};
+		if (!scrobbler)
+			return res;
+
 		Session& session {_db.getTLSSession()};
 		auto transaction {session.createSharedTransaction()};
 
-		const User::pointer user {User::getById(session, userId)};
-		if (!user)
-			return res;
-
-		const ObjectPtr<TrackList> history {getListensTrackList(session, user)};
-		if (history)
-		{
-			for (const Artist::pointer& artist : history->getArtistsReverse(clusterIds, linkType, range, moreResults))
-				res.push_back(artist->getId());
-		}
-
-		return res;
+		return Database::Listen::getRecentArtists(session, userId, *scrobbler, clusterIds, linkType, range);
 	}
 
 	ScrobblingService::ReleaseContainer
-	ScrobblingService::getRecentReleases(Database::UserId userId,
-									const std::vector<Database::ClusterId>& clusterIds,
-									std::optional<Database::Range> range,
-									bool& moreResults)
+	ScrobblingService::getRecentReleases(UserId userId, const std::vector<ClusterId>& clusterIds, Range range)
 	{
 		ReleaseContainer res;
 
+		auto scrobbler {getUserScrobbler(userId)};
+		if (!scrobbler)
+			return res;
+
 		Session& session {_db.getTLSSession()};
 		auto transaction {session.createSharedTransaction()};
 
-		const User::pointer user {User::getById(session, userId)};
-		if (!user)
-			return res;
-
-		const ObjectPtr<TrackList> history {getListensTrackList(session, user)};
-		if (history)
-		{
-			for (const Release::pointer& release : history->getReleasesReverse(clusterIds, range, moreResults))
-				res.push_back(release->getId());
-		}
-
-		return res;
+		return Database::Listen::getRecentReleases(session, userId, *scrobbler, clusterIds, range);
 	}
 
 	ScrobblingService::TrackContainer
-	ScrobblingService::getRecentTracks(Database::UserId userId,
-										const std::vector<Database::ClusterId>& clusterIds,
-										std::optional<Database::Range> range,
-										bool& moreResults)
+	ScrobblingService::getRecentTracks(UserId userId, const std::vector<ClusterId>& clusterIds, Range range)
 	{
 		TrackContainer res;
 
+		auto scrobbler {getUserScrobbler(userId)};
+		if (!scrobbler)
+			return res;
+
 		Session& session {_db.getTLSSession()};
 		auto transaction {session.createSharedTransaction()};
 
-		const User::pointer user {User::getById(session, userId)};
-		if (!user)
-			return res;
-
-		const ObjectPtr<TrackList> history {getListensTrackList(session, user)};
-		if (history)
-		{
-			for (const Track::pointer& track : history->getTracksReverse(clusterIds, range, moreResults))
-				res.push_back(track->getId());
-		}
-
-		return res;
+		return Database::Listen::getRecentTracks(session, userId, *scrobbler, clusterIds, range);
 	}
 
-
 	// Top
 	ScrobblingService::ArtistContainer
-	ScrobblingService::getTopArtists(UserId userId,
-								const std::vector<Database::ClusterId>& clusterIds,
-								std::optional<Database::TrackArtistLinkType> linkType,
-								std::optional<Database::Range> range,
-								bool& moreResults)
+	ScrobblingService::getTopArtists(UserId userId, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, Range range)
 	{
 		ArtistContainer res;
 
+		auto scrobbler {getUserScrobbler(userId)};
+		if (!scrobbler)
+			return res;
+
 		Session& session {_db.getTLSSession()};
 		auto transaction {session.createSharedTransaction()};
 
-		const User::pointer user {User::getById(session, userId)};
-		if (!user)
-			return res;
-
-		const ObjectPtr<TrackList> history {getListensTrackList(session, user)};
-		if (history)
-		{
-			for (const Artist::pointer& artist : history->getTopArtists(clusterIds, linkType, range, moreResults))
-				res.push_back(artist->getId());
-		}
-
-		return res;
+		return Database::Listen::getTopArtists(session, userId, *scrobbler, clusterIds, linkType, range);
 	}
 
 	ScrobblingService::ReleaseContainer
-	ScrobblingService::getTopReleases(Database::UserId userId,
-								const std::vector<Database::ClusterId>& clusterIds,
-								std::optional<Database::Range> range,
-								bool& moreResults)
+	ScrobblingService::getTopReleases(UserId userId, const std::vector<ClusterId>& clusterIds, Range range)
 	{
 		ReleaseContainer res;
 
+		auto scrobbler {getUserScrobbler(userId)};
+		if (!scrobbler)
+			return res;
+
 		Session& session {_db.getTLSSession()};
 		auto transaction {session.createSharedTransaction()};
 
-		const User::pointer user {User::getById(session, userId)};
-		if (!user)
-			return res;
-
-		const ObjectPtr<TrackList> history {getListensTrackList(session, user)};
-		if (history)
-		{
-			for (const Release::pointer& release : history->getTopReleases(clusterIds, range, moreResults))
-				res.push_back(release->getId());
-		}
-
-		return res;
+		return Database::Listen::getTopReleases(session, userId, *scrobbler, clusterIds, range);
 	}
 
 	ScrobblingService::TrackContainer
-	ScrobblingService::getTopTracks(Database::UserId userId,
-								const std::vector<Database::ClusterId>& clusterIds,
-								std::optional<Database::Range> range,
-								bool& moreResults)
+	ScrobblingService::getTopTracks(UserId userId, const std::vector<ClusterId>& clusterIds, Range range)
 	{
 		TrackContainer res;
 
+		auto scrobbler {getUserScrobbler(userId)};
+		if (!scrobbler)
+			return res;
+
 		Session& session {_db.getTLSSession()};
 		auto transaction {session.createSharedTransaction()};
 
-		const User::pointer user {User::getById(session, userId)};
-		if (!user)
-			return res;
-
-		if (const ObjectPtr<TrackList> history {getListensTrackList(session, user)})
-		{
-			for (const Track::pointer& track : history->getTopTracks(clusterIds, range, moreResults))
-				res.push_back(track->getId());
-		}
-
-		return res;
+		return Database::Listen::getTopTracks(session, userId, *scrobbler, clusterIds, range);
 	}
 
-	Database::ObjectPtr<Database::TrackList>
-	ScrobblingService::getListensTrackList(Session& session, Database::ObjectPtr<Database::User> user)
+	void
+	ScrobblingService::star(UserId userId, ArtistId artistId)
 	{
-		return _scrobblers[user->getScrobbler()]->getListensTrackList(session, user);
+		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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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
 

src/libs/services/scrobbling/impl/ScrobblingService.hpp

@@ -41,39 +41,57 @@ namespace Scrobbling
 			ArtistContainer getRecentArtists(Database::UserId userId,
 												const std::vector<Database::ClusterId>& clusterIds,
 												std::optional<Database::TrackArtistLinkType> linkType,
-												std::optional<Database::Range> range,
-												bool& moreResults) override;
+												Database::Range range) override;
 
 			ReleaseContainer getRecentReleases(Database::UserId userId,
 												const std::vector<Database::ClusterId>& clusterIds,
-												std::optional<Database::Range> range,
-												bool& moreResults) override;
+												Database::Range range) override;
 
 			TrackContainer getRecentTracks(Database::UserId userId,
 												const std::vector<Database::ClusterId>& clusterIds,
-												std::optional<Database::Range> range,
-												bool& moreResults) override;
+												Database::Range range) override;
 
 			ArtistContainer getTopArtists(Database::UserId userId,
 												const std::vector<Database::ClusterId>& clusterIds,
 												std::optional<Database::TrackArtistLinkType> linkType,
-												std::optional<Database::Range> range,
-												bool& moreResults) override;
+												Database::Range range) override;
 
 			ReleaseContainer getTopReleases(Database::UserId userId,
 												const std::vector<Database::ClusterId>& clusterIds,
-												std::optional<Database::Range> range,
-												bool& moreResults) override;
+												Database::Range range) override;
 
 			TrackContainer getTopTracks(Database::UserId userId,
 												const std::vector<Database::ClusterId>& clusterIds,
-												std::optional<Database::Range> range,
-												bool& moreResults) override;
+												Database::Range range) override;
 
-			Database::ObjectPtr<Database::TrackList> getListensTrackList(Database::Session& session, Database::ObjectPtr<Database::User> user);
+			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;
+			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 artistId) 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;
+			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);
+
 			Database::Db& _db;
 			std::unordered_map<Database::Scrobbler, std::unique_ptr<IScrobbler>> _scrobblers;
 	};

src/libs/services/scrobbling/impl/ScrobblingService.impl.hpp

@@ -0,0 +1,93 @@
+/*
+ * 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;
+
+		{
+			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 = StarredObjType::create(session, obj, user, *scrobbler);
+			}
+			starredObj.modify()->setDateTime(Wt::WDateTime::currentDateTime());
+		}
+		_scrobblers[*scrobbler]->onStarred(userId, objId);
+	}
+
+	template <typename ObjType, typename ObjIdType, typename StarredObjType>
+	void
+	ScrobblingService::unstar(UserId userId, ObjIdType objId)
+	{
+		auto scrobbler {getUserScrobbler(userId)};
+		if (!scrobbler)
+			return;
+
+		{
+			Session& session {_db.getTLSSession()};
+			auto transaction {session.createUniqueTransaction()};
+
+			if (typename StarredObjType::pointer starredObj {StarredObjType::find(session, objId, userId, *scrobbler)})
+				starredObj.remove();
+		}
+		_scrobblers[*scrobbler]->onUnstarred(userId, objId);
+	}
+
+	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()};
+
+		return StarredObjType::find(session, objId, userId, *scrobbler);
+	}
+
+} // ns Scrobbling
+

src/libs/services/scrobbling/impl/internal/InternalScrobbler.cpp

@@ -20,22 +20,19 @@
 #include "InternalScrobbler.hpp"
 
 #include "services/database/Db.hpp"
+#include "services/database/Listen.hpp"
 #include "services/database/Session.hpp"
-#include "services/database/Track.hpp"
-#include "services/database/TrackList.hpp"
 #include "services/database/User.hpp"
-#include "utils/Logger.hpp"
+#include "services/database/Track.hpp"
 
 namespace Scrobbling
 {
-	static const std::string historyTracklistName {"__scrobbler_internal_history__"};
-
 	InternalScrobbler::InternalScrobbler(Database::Db& db)
-	: _db {db}
+		: _db {db}
 	{}
 
 	void
-	InternalScrobbler::listenStarted(const Listen& /*listen*/)
+	InternalScrobbler::listenStarted(const Listen&)
 	{
 		// nothing to do
 	}
@@ -43,7 +40,7 @@ namespace Scrobbling
 	void
 	InternalScrobbler::listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration)
 	{
-		// record tracks that have been played for at least of few seconds...
+		// only record tracks that have been played for at least of few seconds...
 		if (duration && *duration < std::chrono::seconds {5})
 			return;
 
@@ -54,29 +51,20 @@ namespace Scrobbling
 	InternalScrobbler::addTimedListen(const TimedListen& listen)
 	{
 		Database::Session& session {_db.getTLSSession()};
-
 		auto transaction {session.createUniqueTransaction()};
 
-		const Database::User::pointer user {Database::User::getById(session, listen.userId)};
+		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;
 
-		Database::TrackList::pointer tracklist {getListensTrackList(session, user)};
-		if (!tracklist)
-			tracklist = Database::TrackList::create(session, historyTracklistName, Database::TrackList::Type::Internal, false, user);
-
-		const Database::Track::pointer track {Database::Track::getById(session, listen.trackId)};
+		const Database::Track::pointer track {Database::Track::find(session, listen.trackId)};
 		if (!track)
 			return;
 
-		Database::TrackListEntry::create(session, track, getListensTrackList(session, user), listen.listenedAt);
+		Database::Listen::create(session, user, track, Database::Scrobbler::Internal, listen.listenedAt);
 	}
-
-	Database::TrackList::pointer
-	InternalScrobbler::getListensTrackList(Database::Session& session, Database::ObjectPtr<Database::User> user)
-	{
-		return Database::TrackList::get(session, historyTracklistName, Database::TrackList::Type::Internal, user);
-	}
-
 } // Scrobbling
 

src/libs/services/scrobbling/impl/internal/InternalScrobbler.hpp

@@ -34,14 +34,12 @@ namespace Scrobbling
 			InternalScrobbler(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;
 
-			Database::ObjectPtr<Database::TrackList> getListensTrackList(Database::Session& session, Database::ObjectPtr<Database::User> user) override;
-
-			Database::Db&	_db;
+			Database::Db&			_db;
 	};
 } // Scrobbling
 

src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzScrobbler.cpp

@@ -46,7 +46,7 @@ namespace
 	{
 		auto transaction {session.createSharedTransaction()};
 
-		const Database::Track::pointer track {Database::Track::getById(session, trackId)};
+		const Database::Track::pointer track {Database::Track::find(session, trackId)};
 		if (!track)
 			return false;
 
@@ -62,7 +62,7 @@ namespace
 	{
 		auto transaction {session.createSharedTransaction()};
 
-		const Database::Track::pointer track {Database::Track::getById(session, listen.trackId)};
+		const Database::Track::pointer track {Database::Track::find(session, listen.trackId)};
 		if (!track)
 			return std::nullopt;
 
@@ -179,12 +179,6 @@ namespace Scrobbling::ListenBrainz
 		enqueListen(listen, listen.listenedAt);
 	}
 
-	Database::TrackList::pointer
-	Scrobbler::getListensTrackList(Database::Session& session, Database::User::pointer user)
-	{
-		return Utils::getListensTrackList(session, user);
-	}
-
 	void
 	Scrobbler::enqueListen(const Listen& listen, const Wt::WDateTime& timePoint)
 	{

src/libs/services/scrobbling/impl/listenbrainz/ListenBrainzScrobbler.hpp

@@ -49,11 +49,9 @@ namespace Scrobbling::ListenBrainz
 			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::ObjectPtr<Database::TrackList> getListensTrackList(Database::Session& session, Database::ObjectPtr<Database::User> user) override;
 
 			// Submit listens
 			void enqueListen(const Listen& listen, const Wt::WDateTime& timePoint);
-			//std::optional<SendQueue::RequestData> createSubmitListenRequestData(const Listen& listen, const Wt::WDateTime& timePoint);
 
 			boost::asio::io_context&	_ioContext;
 			Database::Db&				_db;

src/libs/services/scrobbling/impl/listenbrainz/ListensSynchronizer.cpp

@@ -27,6 +27,7 @@
 
 #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/Track.hpp"
@@ -87,10 +88,10 @@ namespace
 		}
 	}
 
-	Database::Track::pointer
+	Database::TrackId
 	tryMatchListen(Database::Session& session, const Wt::Json::Object& metadata)
 	{
-		Database::Track::pointer track;
+		using namespace Database;
 
 		// first try to get the associated track using MBIDs, and then fallback on names
 		if (metadata.type("additional_info") == Wt::Json::Type::Object)
@@ -98,30 +99,29 @@ namespace
 			const Wt::Json::Object& additionalInfo = metadata.get("additional_info");
 			if (std::optional<UUID> recordingMBID {UUID::fromString(additionalInfo.get("recording_mbid").orIfNull(""))})
 			{
-				const auto tracks {Database::Track::getByRecordingMBID(session, *recordingMBID)};
+				const auto tracks {Track::findByRecordingMBID(session, *recordingMBID)};
 				// if duplicated files, do not record it (let the user correct its database)
 				if (tracks.size() == 1)
-					track = tracks.front();
+					return tracks.front()->getId();
 			}
 		}
 
-		if (track)
-			return track;
-
 		// these fields are mandatory
 		const std::string trackName {static_cast<std::string>(metadata.get("track_name"))};
 		const std::string releaseName {static_cast<std::string>(metadata.get("release_name"))};
 
-		auto tracks {Database::Track::getByNameAndReleaseName(session, trackName, releaseName)};
-		if (tracks.size() > 1)
+		auto tracks {Track::findByNameAndReleaseName(session, trackName, releaseName)};
+		if (tracks.results.size() > 1)
 		{
-			tracks.erase(std::remove_if(std::begin(tracks), std::end(tracks),
-				[&](const Database::Track::pointer track)
+			tracks.results.erase(std::remove_if(std::begin(tracks.results), std::end(tracks.results),
+				[&](const TrackId trackId)
 				{
+					const Track::pointer track {Track::find(session, trackId)};
+
 					if (std::string artistName {metadata.get("artist_name").orIfNull("")}; !artistName.empty())
 					{
-						const auto& artists {track->getArtists({Database::TrackArtistLinkType::Artist})};
-						if (std::none_of(std::begin(artists), std::end(artists), [&](const Database::Artist::pointer& artist) { return artist->getName() == artistName; }))
+						const auto& artists {track->getArtists({TrackArtistLinkType::Artist})};
+						if (std::none_of(std::begin(artists), std::end(artists), [&](const Artist::pointer& artist) { return artist->getName() == artistName; }))
 							return true;
 					}
 					if (metadata.type("additional_info") == Wt::Json::Type::Object)
@@ -145,13 +145,13 @@ namespace
 					}
 
 					return false;
-				}), std::end(tracks));
+				}), std::end(tracks.results));
 		}
 
-		if (tracks.size() == 1)
-			track = tracks.front();
+		if (tracks.results.size() == 1)
+			return tracks.results.front();
 
-		return track;
+		return {};
 	}
 
 	struct ParseGetListensResult
@@ -198,8 +198,8 @@ namespace
 				else if (listenedAt < result.oldestEntry)
 					result.oldestEntry = listenedAt;
 
-				if (const Database::Track::pointer track {tryMatchListen(session, metadata)})
-					result.matchedListens.emplace_back(Scrobbling::TimedListen {{userId, track->getId()}, listenedAt});
+				if (Database::TrackId trackId {tryMatchListen(session, metadata)}; trackId.isValid())
+					result.matchedListens.emplace_back(Scrobbling::TimedListen {{userId, trackId}, listenedAt});
 			}
 		}
 		catch (const Wt::WException& error)
@@ -234,15 +234,18 @@ namespace Scrobbling::ListenBrainz
 
 			auto transaction {session.createUniqueTransaction()};
 
-			const Database::User::pointer user {Database::User::getById(session, listen.userId)};
+			if (Database::Listen::find(session, listen.userId, listen.trackId, Database::Scrobbler::ListenBrainz, listen.listenedAt))
+				return;
+
+			const Database::User::pointer user {Database::User::find(session, listen.userId)};
 			if (!user)
 				return;
 
-			const Database::Track::pointer track {Database::Track::getById(session, listen.trackId)};
+			const Database::Track::pointer track {Database::Track::find(session, listen.trackId)};
 			if (!track)
 				return;
 
-			Database::TrackListEntry::create(session, track, Utils::getOrCreateListensTrackList(session, user), listen.listenedAt);
+			Database::Listen::create(session, user, track, Database::Scrobbler::ListenBrainz, listen.listenedAt);
 
 			UserContext& context {getUserContext(listen.userId)};
 			if (context.listenCount)
@@ -304,14 +307,14 @@ namespace Scrobbling::ListenBrainz
 
 		assert(!isFetching());
 
-		std::vector<Database::UserId> userIds;
+		Database::RangeResults<Database::UserId> userIds;
 		{
 			Database::Session& session {_db.getTLSSession()};
 			auto transaction {session.createSharedTransaction()};
-			userIds = Database::User::getAllIds(_db.getTLSSession());
+			userIds = Database::User::find(_db.getTLSSession(), Database::Range {});
 		}
 
-		for (const Database::UserId userId : userIds)
+		for (const Database::UserId userId : userIds.results)
 		{
 			if (Utils::getListenBrainzToken(_db.getTLSSession(), userId))
 				startGetListens(getUserContext(userId));
@@ -458,25 +461,22 @@ namespace Scrobbling::ListenBrainz
 
 		auto transaction {session.createUniqueTransaction()};
 
-		Database::User::pointer user {Database::User::getById(session, context.userId)};
+		Database::User::pointer user {Database::User::find(session, context.userId)};
 		if (!user)
 			return;
 
-		Database::TrackList::pointer tracklist {Utils::getOrCreateListensTrackList(session, user)};
-
 		for (const TimedListen& listen : parseResult.matchedListens)
 		{
-			const Database::Track::pointer track {Database::Track::getById(session, listen.trackId)};
+			const Database::Track::pointer track {Database::Track::find(session, listen.trackId)};
 			if (!track)
 				continue;
 
-			if (!tracklist->getEntryByTrackAndDateTime(track, listen.listenedAt))
-			{
-				context.importedListenCount++;
-				Database::TrackListEntry::create(session, track, tracklist, listen.listenedAt);
-			}
+			if (Database::Listen::find(session, listen.userId, listen.trackId, Database::Scrobbler::ListenBrainz, listen.listenedAt))
+				continue;
+
+			Database::Listen::create(session, user, track, Database::Scrobbler::ListenBrainz, listen.listenedAt);
+			context.importedListenCount++;
 		}
 	}
-
 } // namespace Scrobbling::ListenBrainz
 

src/libs/services/scrobbling/impl/listenbrainz/ListensSynchronizer.hpp

@@ -24,7 +24,6 @@
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/io_context_strand.hpp>
 #include <boost/asio/steady_timer.hpp>
-#include <Wt/Dbo/Dbo.h>
 
 #include "services/database/Types.hpp"
 #include "services/scrobbling/Listen.hpp"

src/libs/services/scrobbling/impl/listenbrainz/LovesSynchronizer.hpp

@@ -0,0 +1,92 @@
+/*
+ * 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/scrobbling/Listen.hpp"
+
+namespace Database
+{
+	class Db;
+	class Session;
+	class TrackList;
+	class User;
+}
+
+namespace Scrobbling::ListenBrainz
+{
+	class ListensSynchronizer
+	{
+		public:
+			ListensSynchronizer(boost::asio::io_context& ioContext, Database::Db& db, std::string_view baseAPIUrl);
+
+			void saveListen(const TimedListen& listen);
+
+		private:
+			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						fetching {};
+
+				// resetted at each fetch
+				std::string		listenBrainzUserName; // need to be resolved first
+				Wt::WDateTime	maxDateTime;
+				std::size_t		fetchedLoveCount{};
+				std::size_t		matchedLoveCount{};
+				std::size_t		importedLoveCount{};
+			};
+
+			UserContext& getUserContext(Database::UserId userId);
+			bool isFetching() const;
+			void scheduleGetListens(std::chrono::seconds fromNow);
+			void startGetListens();
+			void startGetListens(UserContext& context);
+			void onGetListensEnded(UserContext& context);
+			void enqueValidateToken(UserContext& context);
+			void enqueGetListenCount(UserContext& context);
+			void enqueGetListens(UserContext& context);
+			void									processGetListensResponse(std::string_view body, UserContext& context);
+
+			boost::asio::io_context&		_ioContext;
+			boost::asio::io_context::strand	_strand {_ioContext};
+			Database::Db&					_db;
+			std::string						_baseAPIUrl;
+			boost::asio::steady_timer		_getListensTimer {_ioContext};
+
+			std::unordered_map<Database::UserId, UserContext> _userContexts;
+
+			const std::size_t			_maxSyncListenCount;
+			const std::chrono::hours	_syncListensPeriod;
+	};
+} // Scrobbling::ListenBrainz
+

src/libs/services/scrobbling/impl/listenbrainz/Utils.cpp

@@ -34,7 +34,7 @@ namespace Scrobbling::ListenBrainz::Utils
 	{
 		auto transaction {session.createSharedTransaction()};
 
-		const Database::User::pointer user {Database::User::getById(session, userId)};
+		const Database::User::pointer user {Database::User::find(session, userId)};
 		if (!user)
 			return std::nullopt;
 
@@ -43,21 +43,4 @@ namespace Scrobbling::ListenBrainz::Utils
 
 		return user->getListenBrainzToken();
 	}
-
-	Database::TrackList::pointer
-	getListensTrackList(Database::Session& session, Database::User::pointer user)
-	{
-		return Database::TrackList::get(session, historyTracklistName, Database::TrackList::Type::Internal, user);
-	}
-
-	Database::TrackList::pointer
-	getOrCreateListensTrackList(Database::Session& session, Database::User::pointer user)
-	{
-		Database::TrackList::pointer tracklist {getListensTrackList(session, user)};
-		if (!tracklist)
-			tracklist = Database::TrackList::create(session, historyTracklistName, Database::TrackList::Type::Internal, false, user);
-
-		return tracklist;
-	}
-
 }

src/libs/services/scrobbling/impl/listenbrainz/Utils.hpp

@@ -19,21 +19,18 @@
 
 #pragma once
 
-#include <Wt/Dbo/ptr.h>
 #include "utils/UUID.hpp"
 
 #include "services/database/Types.hpp"
+#include "services/database/UserId.hpp"
 
 namespace Database
 {
 	class Session;
-	class TrackList;
 	class User;
 }
 
 namespace Scrobbling::ListenBrainz::Utils
 {
 	std::optional<UUID>							getListenBrainzToken(Database::Session& session, Database::UserId userId);
-	Database::ObjectPtr<Database::TrackList>	getOrCreateListensTrackList(Database::Session& session, Database::ObjectPtr<Database::User> user);
-	Database::ObjectPtr<Database::TrackList>	getListensTrackList(Database::Session& session, Database::ObjectPtr<Database::User> user);
 }