Migrated scrobbling stuff

src/libs/services/CMakeLists.txt

@@ -1 +1,6 @@
+add_subdirectory(auth)
 add_subdirectory(cover)
+add_subdirectory(database)
+add_subdirectory(recommendation)
+add_subdirectory(scanner)
+add_subdirectory(scrobbling)

src/libs/services/auth/CMakeLists.txt

@@ -0,0 +1,40 @@
+
+add_library(lmsauth SHARED
+	impl/AuthTokenService.cpp
+	impl/AuthServiceBase.cpp
+	impl/EnvService.cpp
+	impl/LoginThrottler.cpp
+	impl/PasswordServiceBase.cpp
+	impl/http-headers/HttpHeadersEnvService.cpp
+	impl/internal/InternalPasswordService.cpp
+	)
+
+target_include_directories(lmsauth INTERFACE
+	include
+	)
+
+target_include_directories(lmsauth PRIVATE
+	include
+	impl
+	)
+
+target_link_libraries(lmsauth PRIVATE
+	lmsutils
+	lmsdatabase
+	)
+
+target_link_libraries(lmsauth PUBLIC
+	pthread
+	Boost::system
+	Wt::Wt
+	)
+
+if (USE_PAM)
+	target_compile_options(lmsauth PRIVATE "-DLMS_SUPPORT_PAM")
+	target_sources(lmsauth PRIVATE impl/pam/PAMPasswordService.cpp)
+	target_include_directories(lmsauth PRIVATE  ${PAM_INCLUDE_DIR})
+	target_link_libraries(lmsauth PRIVATE ${PAM_LIBRARIES})
+endif (USE_PAM)
+
+install(TARGETS lmsauth DESTINATION lib)
+

src/libs/services/auth/impl/AuthServiceBase.cpp

@@ -0,0 +1,71 @@
+/*
+ * 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 "AuthServiceBase.hpp"
+
+#include "database/Db.hpp"
+#include "database/Session.hpp"
+#include "database/User.hpp"
+#include "utils/Logger.hpp"
+
+namespace Auth
+{
+	using namespace Database;
+
+	AuthServiceBase::AuthServiceBase(Db& db)
+	: _db {db}
+	{}
+
+	UserId
+	AuthServiceBase::getOrCreateUser(std::string_view loginName)
+	{
+		Session& session {getDbSession()};
+		auto transaction {session.createUniqueTransaction()};
+
+		User::pointer user {User::getByLoginName(session, loginName)};
+		if (!user)
+		{
+			const UserType type {User::getCount(session) == 0 ? UserType::ADMIN : UserType::REGULAR};
+
+			LMS_LOG(AUTH, DEBUG) << "Creating user '" << loginName << "', admin = " << (type == UserType::ADMIN);
+
+			user = User::create(session, loginName);
+			user.modify()->setType(type);
+		}
+
+		return user->getId();
+	}
+
+	void
+	AuthServiceBase::onUserAuthenticated(UserId userId)
+	{
+		Session& session {getDbSession()};
+		auto transaction {session.createUniqueTransaction()};
+
+		User::pointer user {User::getById(session, userId)};
+		if (user)
+			user.modify()->setLastLogin(Wt::WDateTime::currentDateTime());
+	}
+
+	Session&
+	AuthServiceBase::getDbSession()
+	{
+		return _db.getTLSSession();
+	}
+}

src/libs/services/auth/impl/AuthServiceBase.hpp

@@ -0,0 +1,46 @@
+/*
+ * 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 "database/Types.hpp"
+
+namespace Database
+{
+	class Db;
+	class Session;
+}
+
+namespace Auth
+{
+	class AuthServiceBase
+	{
+		protected:
+			AuthServiceBase(Database::Db& db);
+
+			Database::UserId	getOrCreateUser(std::string_view loginName);
+			void				onUserAuthenticated(Database::UserId userId);
+
+			Database::Session&		getDbSession();
+
+		private:
+			Database::Db&		_db;
+	};
+}

src/libs/services/auth/impl/AuthTokenService.cpp

@@ -0,0 +1,142 @@
+/*
+ * 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/>.
+ */
+
+#include "AuthTokenService.hpp"
+
+#include <Wt/Auth/HashFunction.h>
+#include <Wt/Auth/PasswordStrengthValidator.h>
+#include <Wt/WRandom.h>
+
+#include "auth/Types.hpp"
+#include "database/Session.hpp"
+#include "database/User.hpp"
+#include "utils/Exception.hpp"
+#include "utils/Logger.hpp"
+
+namespace Auth
+{
+
+	std::unique_ptr<IAuthTokenService> createAuthTokenService(Database::Db& db, std::size_t maxThrottlerEntries)
+	{
+		return std::make_unique<AuthTokenService>(db, maxThrottlerEntries);
+	}
+
+	static const Wt::Auth::SHA1HashFunction sha1Function;
+
+	AuthTokenService::AuthTokenService(Database::Db& db, std::size_t maxThrottlerEntries)
+	: AuthServiceBase {db}
+	, _loginThrottler {maxThrottlerEntries}
+	{
+	}
+
+	std::string
+	AuthTokenService::createAuthToken(Database::UserId userId, const Wt::WDateTime& expiry)
+	{
+		const std::string secret {Wt::WRandom::generateId(32)};
+		const std::string secretHash {sha1Function.compute(secret, {})};
+
+		Database::Session& session {getDbSession()};
+
+		auto transaction {session.createUniqueTransaction()};
+
+		Database::User::pointer user {Database::User::getById(session, userId)};
+		if (!user)
+			throw Exception {"User deleted"};
+
+		Database::AuthToken::pointer authToken {Database::AuthToken::create(session, secretHash, expiry, user)};
+
+		LMS_LOG(UI, DEBUG) << "Created auth token for user '" << user->getLoginName() << "', expiry = " << expiry.toString();
+
+		if (user->getAuthTokensCount() >= 50)
+			Database::AuthToken::removeExpiredTokens(session, Wt::WDateTime::currentDateTime());
+
+		return secret;
+	}
+
+	std::optional<AuthTokenService::AuthTokenProcessResult::AuthTokenInfo>
+	AuthTokenService::processAuthToken(std::string_view secret)
+	{
+		const std::string secretHash {sha1Function.compute(std::string {secret}, {})};
+
+		Database::Session& session {getDbSession()};
+		auto transaction {session.createUniqueTransaction()};
+
+		Database::AuthToken::pointer authToken {Database::AuthToken::getByValue(session, secretHash)};
+		if (!authToken)
+			return std::nullopt;
+
+		if (authToken->getExpiry() < Wt::WDateTime::currentDateTime())
+		{
+			authToken.remove();
+			return std::nullopt;
+		}
+
+		LMS_LOG(UI, DEBUG) << "Found auth token for user '" << authToken->getUser()->getLoginName() << "'!";
+
+		AuthTokenService::AuthTokenProcessResult::AuthTokenInfo res {authToken->getUser()->getId(), authToken->getExpiry()};
+		authToken.remove();
+
+		return res;
+	}
+
+	AuthTokenService::AuthTokenProcessResult
+	AuthTokenService::processAuthToken(const boost::asio::ip::address& clientAddress, std::string_view tokenValue)
+	{
+		// Do not waste too much resource on brute force attacks (optim)
+		{
+			std::shared_lock lock {_mutex};
+
+			if (_loginThrottler.isClientThrottled(clientAddress))
+				return AuthTokenProcessResult {AuthTokenProcessResult::State::Throttled};
+		}
+
+		auto res {processAuthToken(tokenValue)};
+		{
+			std::unique_lock lock {_mutex};
+
+			if (_loginThrottler.isClientThrottled(clientAddress))
+				return AuthTokenProcessResult {AuthTokenProcessResult::State::Throttled};
+
+			if (!res)
+			{
+				_loginThrottler.onBadClientAttempt(clientAddress);
+				return AuthTokenProcessResult {AuthTokenProcessResult::State::Denied};
+			}
+
+			_loginThrottler.onGoodClientAttempt(clientAddress);
+			onUserAuthenticated(res->userId);
+			return AuthTokenProcessResult {AuthTokenProcessResult::State::Granted, std::move(*res)};
+		}
+	}
+
+	void
+	AuthTokenService::clearAuthTokens(Database::UserId userId)
+	{
+		Database::Session& session {getDbSession()};
+
+		auto transaction {session.createUniqueTransaction()};
+
+		Database::User::pointer user {Database::User::getById(session, userId)};
+		if (!user)
+			throw Exception {"User deleted"};
+
+		user.modify()->clearAuthTokens();
+	}
+
+} // namespace Auth

src/libs/services/auth/impl/AuthTokenService.hpp

@@ -0,0 +1,55 @@
+/*
+ * 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 <shared_mutex>
+
+#include "auth/IAuthTokenService.hpp"
+#include "AuthServiceBase.hpp"
+#include "LoginThrottler.hpp"
+
+namespace Database
+{
+	class Session;
+}
+
+namespace Auth
+{
+	class AuthTokenService : public IAuthTokenService, public AuthServiceBase
+	{
+		public:
+			AuthTokenService(Database::Db& db, std::size_t maxThrottlerEntries);
+
+			AuthTokenService(const AuthTokenService&) = delete;
+			AuthTokenService& operator=(const AuthTokenService&) = delete;
+			AuthTokenService(AuthTokenService&&) = delete;
+			AuthTokenService& operator=(AuthTokenService&&) = delete;
+
+		private:
+			AuthTokenProcessResult	processAuthToken(const boost::asio::ip::address& clientAddress, std::string_view tokenValue) override;
+			std::string				createAuthToken(Database::UserId userId, const Wt::WDateTime& expiry) override;
+			void					clearAuthTokens(Database::UserId userId) override;
+
+			std::optional<AuthTokenService::AuthTokenProcessResult::AuthTokenInfo> processAuthToken(std::string_view secret);
+
+			std::shared_mutex	_mutex;
+			LoginThrottler		_loginThrottler;
+	};
+}

src/libs/services/auth/impl/EnvService.cpp

@@ -0,0 +1,35 @@
+/*
+ * 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 "auth/IEnvService.hpp"
+
+#include "auth/Types.hpp"
+#include "http-headers/HttpHeadersEnvService.hpp"
+
+namespace Auth
+{
+	std::unique_ptr<IEnvService>
+	createEnvService(std::string_view backendName, Database::Db& db)
+	{
+		if (backendName == "http-headers")
+			return std::make_unique<HttpHeadersEnvService>(db);
+
+		throw Exception {"Authentication backend '" + std::string {backendName} + "' is not supported!"};
+	}
+}

src/libs/services/auth/impl/LoginThrottler.cpp

@@ -0,0 +1,102 @@
+/*
+ * 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/>.
+ */
+
+/* This file contains some classes in order to get info from file using the libavconv */
+
+#include "LoginThrottler.hpp"
+
+#include "utils/Logger.hpp"
+#include "utils/Random.hpp"
+
+namespace Auth {
+
+static
+boost::asio::ip::address_v6
+getAddressWithMask(const boost::asio::ip::address_v6& address, std::size_t prefix)
+{
+	assert(prefix % 8 == 0);
+
+	std::array<uint8_t, 16> truncatedBytes;
+
+	auto bytes {address.to_bytes()};
+	std::copy(std::cbegin(bytes), std::next(std::cbegin(bytes), prefix / 8), truncatedBytes.begin());
+
+	return boost::asio::ip::address_v6 {truncatedBytes};
+}
+
+static
+boost::asio::ip::address
+getAddressToThrottle(const boost::asio::ip::address& address)
+{
+	return address.is_v6() ? getAddressWithMask(address.to_v6(), 64) : address;
+}
+
+void
+LoginThrottler::removeOutdatedEntries()
+{
+	const Wt::WDateTime now {Wt::WDateTime::currentDateTime()};
+
+	for (auto it {std::begin(_attemptsInfo)}; it != std::end(_attemptsInfo); )
+	{
+		if (it->second <= now)
+			it = _attemptsInfo.erase(it);
+		else
+			++it;
+	}
+}
+
+void
+LoginThrottler::onBadClientAttempt(const boost::asio::ip::address& address)
+{
+	const boost::asio::ip::address clientAddress {getAddressToThrottle(address)};
+
+	const Wt::WDateTime now {Wt::WDateTime::currentDateTime()};
+
+	if (_attemptsInfo.size() >= _maxEntries)
+		removeOutdatedEntries();
+	if (_attemptsInfo.size() >= _maxEntries)
+		_attemptsInfo.erase(Random::pickRandom(_attemptsInfo));
+
+	_attemptsInfo[address] = now.addSecs(3);
+
+	LMS_LOG(AUTH, DEBUG) << "Registering bad attempt for '" << clientAddress.to_string() << "'";
+}
+
+void
+LoginThrottler::onGoodClientAttempt(const boost::asio::ip::address& address)
+{
+	const boost::asio::ip::address clientAddress {getAddressToThrottle(address)};
+
+	_attemptsInfo.erase(clientAddress);
+}
+
+bool
+LoginThrottler::isClientThrottled(const boost::asio::ip::address& address) const
+{
+	const boost::asio::ip::address clientAddress {getAddressToThrottle(address)};
+
+	auto it {_attemptsInfo.find(clientAddress)};
+	if (it == _attemptsInfo.end())
+		return false;
+
+	return it->second > Wt::WDateTime::currentDateTime();
+}
+
+} // Auth
+

src/libs/services/auth/impl/LoginThrottler.hpp

@@ -0,0 +1,54 @@
+/*
+ * 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 <shared_mutex>
+#include <string>
+#include <unordered_map>
+
+#include <Wt/WDateTime.h>
+
+#include "utils/NetAddress.hpp"
+#include "utils/Exception.hpp"
+
+namespace Auth {
+
+class LoginThrottler
+{
+	public:
+		LoginThrottler(std::size_t maxEntries) : _maxEntries {maxEntries} {}
+
+		// user must lock these calls to avoid races
+		bool isClientThrottled(const boost::asio::ip::address& address) const;
+		void onBadClientAttempt(const boost::asio::ip::address& address);
+		void onGoodClientAttempt(const boost::asio::ip::address& address);
+
+	private:
+
+		void removeOutdatedEntries();
+
+		const std::size_t _maxEntries;
+
+		std::unordered_map<boost::asio::ip::address, Wt::WDateTime>	_attemptsInfo;
+};
+
+
+} // Auth
+

src/libs/services/auth/impl/PasswordServiceBase.cpp

@@ -0,0 +1,97 @@
+/*
+ * 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/>.
+ */
+
+#include "PasswordServiceBase.hpp"
+
+#include <Wt/Auth/HashFunction.h>
+#include <Wt/WRandom.h>
+
+#include "internal/InternalPasswordService.hpp"
+#ifdef LMS_SUPPORT_PAM
+#include "pam/PAMPasswordService.hpp"
+#endif // LMS_SUPPORT_PAM
+
+#include "auth/Types.hpp"
+#include "database/Session.hpp"
+#include "database/User.hpp"
+#include "utils/Exception.hpp"
+#include "utils/Logger.hpp"
+
+namespace Auth
+{
+
+	static const Wt::Auth::SHA1HashFunction sha1Function;
+
+	std::unique_ptr<IPasswordService>
+	createPasswordService(std::string_view passwordAuthenticationBackend, Database::Db& db, std::size_t maxThrottlerEntries, IAuthTokenService& authTokenService)
+	{
+		if (passwordAuthenticationBackend == "internal")
+			return std::make_unique<InternalPasswordService>(db, maxThrottlerEntries, authTokenService);
+#ifdef LMS_SUPPORT_PAM
+		else if (passwordAuthenticationBackend == "pam")
+			return std::make_unique<PAMPasswordService>(db, maxThrottlerEntries, authTokenService);
+#endif // LMS_SUPPORT_PAM
+
+		throw Exception {"Authentication backend '" + std::string {passwordAuthenticationBackend} + "' is not supported!"};
+	}
+
+	PasswordServiceBase::PasswordServiceBase(Database::Db& db, std::size_t maxThrottlerEntries, IAuthTokenService& authTokenService)
+		: AuthServiceBase {db}
+		, _loginThrottler {maxThrottlerEntries}
+		, _authTokenService {authTokenService}
+	{
+	}
+
+	PasswordServiceBase::CheckResult
+	PasswordServiceBase::checkUserPassword(const boost::asio::ip::address& clientAddress, std::string_view loginName, std::string_view password)
+	{
+		LMS_LOG(AUTH, DEBUG) << "Checking password for user '" << loginName << "'";
+
+		// Do not waste too much resource on brute force attacks (optim)
+		{
+			std::shared_lock lock {_mutex};
+
+			if (_loginThrottler.isClientThrottled(clientAddress))
+				return {CheckResult::State::Throttled};
+		}
+
+		const bool match {checkUserPassword(loginName, password)};
+		{
+			std::unique_lock lock {_mutex};
+
+			if (_loginThrottler.isClientThrottled(clientAddress))
+				return {CheckResult::State::Throttled};
+
+			if (match)
+			{
+				_loginThrottler.onGoodClientAttempt(clientAddress);
+
+				const Database::UserId userId {getOrCreateUser(loginName)};
+				onUserAuthenticated(userId);
+				return {CheckResult::State::Granted, userId};
+			}
+			else
+			{
+				_loginThrottler.onBadClientAttempt(clientAddress);
+				return {CheckResult::State::Denied};
+			}
+		}
+	}
+} // namespace Auth
+

src/libs/services/auth/impl/PasswordServiceBase.hpp

@@ -0,0 +1,62 @@
+/*
+ * 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 <shared_mutex>
+
+#include "auth/IPasswordService.hpp"
+#include "AuthServiceBase.hpp"
+#include "LoginThrottler.hpp"
+
+namespace Database
+{
+	class Db;
+	class Session;
+}
+
+namespace Auth
+{
+
+	class PasswordServiceBase : public IPasswordService, public AuthServiceBase
+	{
+		public:
+			PasswordServiceBase(Database::Db& db, std::size_t maxThrottlerEntries, IAuthTokenService& authTokenService);
+
+			PasswordServiceBase(const PasswordServiceBase&) = delete;
+			PasswordServiceBase& operator=(const PasswordServiceBase&) = delete;
+			PasswordServiceBase(PasswordServiceBase&&) = delete;
+			PasswordServiceBase& operator=(PasswordServiceBase&&) = delete;
+
+		protected:
+			IAuthTokenService&	getAuthTokenService() { return _authTokenService; }
+
+		private:
+			virtual bool	checkUserPassword(std::string_view loginName, std::string_view password) = 0;
+
+			CheckResult		checkUserPassword(const boost::asio::ip::address& clientAddress,
+												std::string_view loginName,
+												std::string_view password) override;
+
+			std::shared_mutex			_mutex;
+			LoginThrottler				_loginThrottler;
+			IAuthTokenService&			_authTokenService;
+	};
+
+} // namespace Auth

src/libs/services/auth/impl/http-headers/HttpHeadersEnvService.cpp

@@ -0,0 +1,67 @@
+/*
+ * 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 "HttpHeadersEnvService.hpp"
+
+#include <Wt/WEnvironment.h>
+
+#include "utils/IConfig.hpp"
+#include "utils/Logger.hpp"
+#include "utils/Service.hpp"
+
+namespace Auth
+{
+
+	HttpHeadersEnvService::HttpHeadersEnvService(Database::Db& db)
+		: AuthServiceBase {db}
+		, _fieldName {Service<IConfig>::get()->getString("http-headers-login-field", "X-Forwarded-User")}
+	{
+		LMS_LOG(AUTH, INFO) << "Using http header field = '" << _fieldName << "'";
+	}
+
+	HttpHeadersEnvService::CheckResult
+	HttpHeadersEnvService::processEnv(const Wt::WEnvironment& env)
+	{
+		const std::string loginName {env.headerValue(_fieldName)};
+		if (loginName.empty())
+			return {CheckResult::State::Denied};
+
+		LMS_LOG(AUTH, DEBUG) << "Extracted login name = '" << loginName <<  "' from HTTP header";
+
+		const Database::UserId userId {getOrCreateUser(loginName)};
+		onUserAuthenticated(userId);
+		return {CheckResult::State::Granted, userId};
+	}
+
+	HttpHeadersEnvService::CheckResult
+	HttpHeadersEnvService::processRequest(const Wt::Http::Request& request)
+	{
+		const std::string loginName {request.headerValue(_fieldName)};
+		if (loginName.empty())
+			return {CheckResult::State::Denied};
+
+		LMS_LOG(AUTH, DEBUG) << "Extracted login name = '" << loginName <<  "' from HTTP header";
+
+		const Database::UserId userId {getOrCreateUser(loginName)};
+		onUserAuthenticated(userId);
+		return {CheckResult::State::Granted, userId};
+	}
+
+} // namespace Auth
+

src/libs/services/auth/impl/http-headers/HttpHeadersEnvService.hpp

@@ -0,0 +1,40 @@
+/*
+ * 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 "auth/IEnvService.hpp"
+#include "AuthServiceBase.hpp"
+
+namespace Auth
+{
+	class HttpHeadersEnvService : public IEnvService, public AuthServiceBase
+	{
+		public:
+			HttpHeadersEnvService(Database::Db& db);
+
+		private:
+			CheckResult	processEnv(const Wt::WEnvironment& env) override;
+			CheckResult	processRequest(const Wt::Http::Request& request) override;
+
+			std::string _fieldName;
+	};
+
+} // namespace Auth
+

src/libs/services/auth/impl/internal/InternalPasswordService.cpp

@@ -0,0 +1,138 @@
+/*
+ * 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/>.
+ */
+
+#include "InternalPasswordService.hpp"
+#include <Wt/WRandom.h>
+
+#include "auth/IAuthTokenService.hpp"
+#include "auth/Types.hpp"
+#include "database/Session.hpp"
+#include "database/User.hpp"
+#include "utils/Exception.hpp"
+#include "utils/Logger.hpp"
+
+namespace Auth
+{
+	InternalPasswordService::InternalPasswordService(Database::Db& db, std::size_t maxThrottlerEntries, IAuthTokenService& authTokenService)
+		: PasswordServiceBase {db, maxThrottlerEntries, authTokenService}
+	{
+		_validator.setMinimumLength(Wt::Auth::PasswordStrengthType::OneCharClass, 4);
+		_validator.setMinimumLength(Wt::Auth::PasswordStrengthType::TwoCharClass, 4);
+		_validator.setMinimumLength(Wt::Auth::PasswordStrengthType::PassPhrase, 4);
+		_validator.setMinimumLength(Wt::Auth::PasswordStrengthType::ThreeCharClass, 4);
+		_validator.setMinimumLength(Wt::Auth::PasswordStrengthType::FourCharClass, 4);
+		_validator.setMinimumPassPhraseWords(1);
+		_validator.setMinimumMatchLength(3);
+	}
+
+	bool
+	InternalPasswordService::checkUserPassword(std::string_view loginName, std::string_view password)
+	{
+		LMS_LOG(AUTH, DEBUG) << "Checking internal password for user '" << loginName << "'";
+
+		Database::User::PasswordHash passwordHash;
+		{
+			Database::Session& session {getDbSession()};
+			auto transaction {session.createSharedTransaction()};
+
+			const Database::User::pointer user {Database::User::getByLoginName(session, loginName)};
+			if (!user)
+			{
+				LMS_LOG(AUTH, DEBUG) << "hashing random stuff";
+				// hash random stuff here to waste some time
+				hashRandomPassword();
+				return false;
+			}
+
+			// Don't allow users being created or coming from other backends
+			passwordHash = user->getPasswordHash();
+			if (passwordHash.salt.empty() || passwordHash.hash.empty())
+			{
+				// hash random stuff here to waste some time
+				hashRandomPassword();
+				return false;
+			}
+		}
+
+		return _hashFunc.verify(std::string {password}, std::string {passwordHash.salt}, std::string {passwordHash.hash});
+	}
+
+	bool
+	InternalPasswordService::canSetPasswords() const
+	{
+		return true;
+	}
+
+	IPasswordService::PasswordAcceptabilityResult
+	InternalPasswordService::checkPasswordAcceptability(std::string_view password, const PasswordValidationContext& context) const
+	{
+		switch (context.userType)
+		{
+			case Database::UserType::ADMIN:
+			case Database::UserType::REGULAR:
+				return _validator.evaluateStrength(std::string {password}, context.loginName, "").isValid() ? PasswordAcceptabilityResult::OK : PasswordAcceptabilityResult::TooWeak;
+			case Database::UserType::DEMO:
+				return password == context.loginName ? PasswordAcceptabilityResult::OK : PasswordAcceptabilityResult::MustMatchLoginName;
+		}
+
+		throw NotImplementedException {};
+	}
+
+	void
+	InternalPasswordService::setPassword(Database::UserId userId, std::string_view newPassword)
+	{
+		const Database::User::PasswordHash passwordHash {hashPassword(newPassword)};
+
+		Database::Session& session {getDbSession()};
+		auto transaction {session.createUniqueTransaction()};
+
+		Database::User::pointer user {Database::User::getById(session, userId)};
+		if (!user)
+			throw Exception {"User not found!"};
+
+		switch (checkPasswordAcceptability(newPassword, PasswordValidationContext {user->getLoginName(), user->getType()}))
+		{
+			case PasswordAcceptabilityResult::OK:
+				break;
+			case PasswordAcceptabilityResult::TooWeak:
+				throw PasswordTooWeakException {};
+			case PasswordAcceptabilityResult::MustMatchLoginName:
+				throw PasswordMustMatchLoginNameException {};
+		}
+
+		user.modify()->setPasswordHash(passwordHash);
+		getAuthTokenService().clearAuthTokens(userId);
+	}
+
+	Database::User::PasswordHash
+	InternalPasswordService::hashPassword(std::string_view password) const
+	{
+		const std::string salt {Wt::WRandom::generateId(32)};
+
+		return {salt, _hashFunc.compute(std::string {password}, salt)};
+	}
+
+	void
+	InternalPasswordService::hashRandomPassword() const
+	{
+		hashPassword(Wt::WRandom::generateId(32));
+	}
+
+} // namespace Auth
+

src/libs/services/auth/impl/internal/InternalPasswordService.hpp

@@ -0,0 +1,52 @@
+/*
+ * 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 <Wt/Auth/HashFunction.h>
+#include <Wt/Auth/PasswordStrengthValidator.h>
+
+#include "database/User.hpp"
+#include "PasswordServiceBase.hpp"
+#include "LoginThrottler.hpp"
+
+namespace Auth
+{
+	class IAuthTokenService;
+
+	class InternalPasswordService : public PasswordServiceBase
+	{
+		public:
+			InternalPasswordService(Database::Db& db, std::size_t maxThrottlerEntries, IAuthTokenService& authTokenService);
+
+		private:
+			bool	checkUserPassword(std::string_view loginName, std::string_view password) override;
+
+			bool	canSetPasswords() const override;
+			PasswordAcceptabilityResult	checkPasswordAcceptability(std::string_view loginName, const PasswordValidationContext& context) const override;
+			void	setPassword(Database::UserId userId, std::string_view newPassword) override;
+
+			Database::User::PasswordHash	hashPassword(std::string_view password) const;
+			void							hashRandomPassword() const;
+
+			const Wt::Auth::BCryptHashFunction	_hashFunc {7}; // TODO parametrize this
+			Wt::Auth::PasswordStrengthValidator	_validator;
+	};
+
+}

src/libs/services/auth/impl/pam/PAMPasswordService.cpp

@@ -0,0 +1,202 @@
+/*
+ * 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/>.
+ */
+
+#include "PAMPasswordService.hpp"
+
+#ifndef LMS_SUPPORT_PAM
+#error "Should not compile this"
+#endif
+
+#include <cstring>
+#include <security/pam_appl.h>
+
+#include "auth/Types.hpp"
+#include "database/Session.hpp"
+#include "utils/Logger.hpp"
+
+namespace Auth
+{
+	class PAMError
+	{
+		public:
+			PAMError(std::string_view msg, pam_handle_t *pamh, int err)
+			{
+				_errorMsg = std::string {msg} + ": " + pam_strerror(pamh, err);
+			}
+
+			std::string_view message() const { return _errorMsg; }
+
+		private:
+			std::string _errorMsg;
+	};
+
+	class PAMContext
+	{
+		public:
+			PAMContext(std::string_view loginName)
+			{
+				int err {pam_start("lms", std::string {loginName}.c_str(), &_conv, &_pamh)};
+				if (err != PAM_SUCCESS)
+					throw PAMError {"start failed", _pamh, err};
+			}
+
+			~PAMContext()
+			{
+				int err {pam_end(_pamh, 0)};
+				if (err != PAM_SUCCESS)
+					LMS_LOG(AUTH, ERROR) << "end failed: " << pam_strerror(_pamh, err);
+			}
+
+			void authenticate(std::string_view password)
+			{
+				AuthenticateConvContext authContext {password};
+				ScopedConvContextSetter scopedContext {*this, authContext};
+
+				int err {pam_authenticate(_pamh, 0)};
+				if (err != PAM_SUCCESS)
+					throw PAMError {"authenticate failed", _pamh, err};
+			}
+
+			void validateAccount()
+			{
+				int err {pam_acct_mgmt(_pamh, PAM_SILENT)};
+				if (err != PAM_SUCCESS)
+					throw PAMError {"acct_mgmt failed", _pamh, err};
+			}
+
+		private:
+			class ConvContext
+			{
+				public:
+					virtual ~ConvContext() = default;
+			};
+
+			class AuthenticateConvContext final : public ConvContext
+			{
+				public:
+					AuthenticateConvContext(std::string_view password) : _password {password} {}
+
+					std::string_view getPassword() const { return _password; }
+
+				private:
+					std::string_view _password;
+			};
+
+			class ScopedConvContextSetter
+			{
+				public:
+					ScopedConvContextSetter(PAMContext& pamContext, ConvContext& convContext)
+						: _pamContext {pamContext}
+					{
+						_pamContext._convContext = &convContext;
+					}
+
+					~ScopedConvContextSetter()
+					{
+						_pamContext._convContext = nullptr;
+					}
+
+					ScopedConvContextSetter(const ScopedConvContextSetter&) = delete;
+					ScopedConvContextSetter(ScopedConvContextSetter&&) = delete;
+					ScopedConvContextSetter& operator=(const ScopedConvContextSetter&) = delete;
+					ScopedConvContextSetter& operator=(ScopedConvContextSetter&&) = delete;
+
+				private:
+					PAMContext& _pamContext;
+			};
+
+
+			static int conv(int msgCount, const pam_message** msgs, pam_response** resps, void* userData)
+			{
+				if (msgCount < 1)
+					return PAM_CONV_ERR;
+				if (!resps || !msgs || !userData)
+					return PAM_CONV_ERR;
+
+				PAMContext& context {*static_cast<PAMContext*>(userData)};
+
+				AuthenticateConvContext* authenticateContext = dynamic_cast<AuthenticateConvContext*>(context._convContext);
+				if (!authenticateContext)
+				{
+					LMS_LOG(AUTH, ERROR) << "Unexpected conv!";
+					return PAM_CONV_ERR;
+				}
+
+				// Only expect a PAM_PROMPT_ECHO_OFF msg
+				if (msgCount != 1 || msgs[0]->msg_style != PAM_PROMPT_ECHO_OFF)
+				{
+					LMS_LOG(AUTH, ERROR) << "Unexpected conv message. Count = " << msgCount;
+					return PAM_CONV_ERR;
+				}
+
+				pam_response* response {static_cast<pam_response*>(malloc(sizeof(pam_response)))};
+				if (!response)
+					return PAM_CONV_ERR;
+
+				response->resp = strdup(std::string {authenticateContext->getPassword()}.c_str());
+
+				*resps = response;
+				return PAM_SUCCESS;
+			}
+
+			ConvContext* _convContext {};
+			pam_conv _conv {&PAMContext::conv, this};
+			pam_handle_t *_pamh {};
+	};
+
+	bool
+	PAMPasswordService::checkUserPassword(std::string_view loginName, std::string_view password)
+	{
+		try
+		{
+			LMS_LOG(AUTH, DEBUG) << "Checking PAM password for user '" << loginName << "'";
+			PAMContext pamContext {loginName};
+
+			pamContext.authenticate(password);
+			pamContext.validateAccount();
+
+			return true;
+		}
+		catch (const PAMError& error)
+		{
+			LMS_LOG(AUTH, ERROR) << "PAM error: " << error.message();
+			return false;
+		}
+	}
+
+	bool
+	PAMPasswordService::canSetPasswords() const
+	{
+		return false;
+	}
+
+	IPasswordService::PasswordAcceptabilityResult
+	PAMPasswordService::checkPasswordAcceptability(std::string_view, const PasswordValidationContext&) const
+	{
+		throw NotImplementedException {};
+	}
+
+	void
+	PAMPasswordService::setPassword(Database::UserId, std::string_view)
+	{
+		throw NotImplementedException {};
+	}
+
+} // namespace Auth
+

src/libs/services/auth/impl/pam/PAMPasswordService.hpp

@@ -0,0 +1,39 @@
+/*
+ * 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 <shared_mutex>
+
+#include "PasswordServiceBase.hpp"
+
+namespace Auth
+{
+	class PAMPasswordService: public PasswordServiceBase
+	{
+		public:
+			using PasswordServiceBase::PasswordServiceBase;
+
+		private:
+			bool	checkUserPassword(std::string_view loginName,std::string_view password) override;
+			bool	canSetPasswords() const override;
+			PasswordAcceptabilityResult	checkPasswordAcceptability(std::string_view loginName, const PasswordValidationContext& context) const override;
+			void	setPassword(Database::UserId userId, std::string_view newPassword) override;
+	};
+}

src/libs/services/auth/include/auth/IAuthTokenService.hpp

@@ -0,0 +1,74 @@
+/*
+ * 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/>.
+ */
+
+/* This file contains some classes in order to get info from file using the libavconv */
+
+#pragma once
+
+#include <optional>
+#include <string>
+#include <string_view>
+#include <boost/asio/ip/address.hpp>
+#include <Wt/WDateTime.h>
+
+#include "database/Types.hpp"
+
+namespace Database
+{
+	class Db;
+	class User;
+}
+
+namespace Auth
+{
+	class IAuthTokenService
+	{
+		public:
+			virtual ~IAuthTokenService() = default;
+
+			// Auth Token services
+			struct AuthTokenProcessResult
+			{
+				enum class State
+				{
+					Granted,
+					Throttled,
+					Denied,
+				};
+
+				struct AuthTokenInfo
+				{
+					Database::UserId userId;
+					Wt::WDateTime expiry;
+				};
+
+				State state {State::Denied};
+				std::optional<AuthTokenInfo>	authTokenInfo {};
+			};
+
+			// Provided token is only accepted once
+			virtual AuthTokenProcessResult	processAuthToken(const boost::asio::ip::address& clientAddress, std::string_view tokenValue) = 0;
+
+			// Returns a one time token
+			virtual std::string				createAuthToken(Database::UserId userid, const Wt::WDateTime& expiry) = 0;
+			virtual void					clearAuthTokens(Database::UserId userid) = 0;
+	};
+
+	std::unique_ptr<IAuthTokenService> createAuthTokenService(Database::Db& db, std::size_t maxThrottlerEntryCount);
+}

src/libs/services/auth/include/auth/IEnvService.hpp

@@ -0,0 +1,69 @@
+/*
+ * 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 <optional>
+#include <string>
+
+#include "database/Types.hpp"
+
+namespace Database
+{
+	class Db;
+	class Session;
+}
+
+namespace Wt
+{
+	class WEnvironment;
+}
+
+namespace Wt::Http
+{
+	class Request;
+}
+
+namespace Auth
+{
+	class IEnvService
+	{
+		public:
+			virtual ~IEnvService() = default;
+
+			// Auth Token services
+			struct CheckResult
+			{
+				enum class State
+				{
+					Granted,
+					Denied,
+					Throttled,
+				};
+
+				State state {State::Denied};
+				std::optional<Database::UserId>	userId {};
+			};
+
+			virtual CheckResult			processEnv(const Wt::WEnvironment& env) = 0;
+			virtual CheckResult			processRequest(const Wt::Http::Request& request) = 0;
+	};
+
+	std::unique_ptr<IEnvService> createEnvService(std::string_view backendName, Database::Db& db);
+} // namespace Auth

src/libs/services/auth/include/auth/IPasswordService.hpp

@@ -0,0 +1,77 @@
+/*
+ * 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 <string_view>
+
+#include <Wt/WDateTime.h>
+#include <Wt/Dbo/ptr.h>
+
+#include <boost/asio/ip/address.hpp>
+#include "auth/Types.hpp"
+#include "database/Types.hpp"
+
+namespace Database
+{
+	class Db;
+	class User;
+}
+
+namespace Auth
+{
+
+	class IAuthTokenService;
+
+	class IPasswordService
+	{
+		public:
+			virtual ~IPasswordService() = default;
+
+			struct CheckResult
+			{
+				enum class State
+				{
+					Granted,
+					Denied,
+					Throttled,
+				};
+				State state {State::Denied};
+				std::optional<Database::UserId> userId {};
+				std::optional<Wt::WDateTime> expiry {};
+			};
+			virtual CheckResult		checkUserPassword(const boost::asio::ip::address& clientAddress,
+														std::string_view loginName,
+														std::string_view password) = 0;
+
+			virtual bool			canSetPasswords() const = 0;
+
+			enum class PasswordAcceptabilityResult
+			{
+				OK,
+				TooWeak,
+				MustMatchLoginName,
+			};
+			virtual PasswordAcceptabilityResult	checkPasswordAcceptability(std::string_view password, const PasswordValidationContext& context) const = 0;
+			virtual void						setPassword(Database::UserId userId, std::string_view newPassword) = 0;
+	};
+
+	std::unique_ptr<IPasswordService>	createPasswordService(std::string_view authPasswordBackend, Database::Db& db, std::size_t maxThrottlerEntryCount, IAuthTokenService& authTokenService);
+}
+

src/libs/services/auth/include/auth/Types.hpp

@@ -0,0 +1,69 @@
+/*
+ * 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 "database/Types.hpp"
+#include "utils/Exception.hpp"
+
+namespace Auth
+{
+	class Exception : public ::LmsException
+	{
+		using LmsException::LmsException;
+	};
+
+	class NotImplementedException : public Exception
+	{
+		public:
+			NotImplementedException() : Auth::Exception {"Not implemented"} {}
+	};
+
+	class UserNotFoundException : public Exception
+	{
+		public:
+			UserNotFoundException() : Auth::Exception {"User not found"} {}
+	};
+
+	struct PasswordValidationContext
+	{
+		std::string loginName;
+		Database::UserType userType;
+	};
+
+	class PasswordException : public Exception
+	{
+		public:
+			using Exception::Exception;
+	};
+
+	class PasswordTooWeakException : public PasswordException
+	{
+		public:
+			PasswordTooWeakException() : PasswordException {"Password too weak"} {}
+	};
+
+	class PasswordMustMatchLoginNameException : public PasswordException
+	{
+		public:
+			PasswordMustMatchLoginNameException() : PasswordException {"Password must match login name"} {}
+	};
+}
+

src/libs/services/database/CMakeLists.txt

@@ -0,0 +1,40 @@
+add_library(lmsdatabase SHARED
+	impl/Artist.cpp
+	impl/Cluster.cpp
+	impl/Db.cpp
+	impl/TrackArtistLink.cpp
+	impl/TrackFeatures.cpp
+	impl/TrackList.cpp
+	impl/Release.cpp
+	impl/ScanSettings.cpp
+	impl/Session.cpp
+	impl/SqlQuery.cpp
+	impl/Track.cpp
+	impl/TrackBookmark.cpp
+	impl/User.cpp
+	impl/Utils.cpp
+	)
+
+target_include_directories(lmsdatabase INTERFACE
+	include
+	)
+
+target_include_directories(lmsdatabase PRIVATE
+	include
+	)
+
+target_link_libraries(lmsdatabase PRIVATE
+	Wt::DboSqlite3
+	)
+
+target_link_libraries(lmsdatabase PUBLIC
+	lmsutils
+	std::filesystem
+	Wt::Dbo
+	)
+
+install(TARGETS lmsdatabase DESTINATION lib)
+
+if(BUILD_TESTING)
+	add_subdirectory(test)
+endif()

src/libs/services/database/impl/Artist.cpp

@@ -0,0 +1,620 @@
+/*
+ * Copyright (C) 2015 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 "database/Artist.hpp"
+
+#include <Wt/Dbo/WtSqlTraits.h>
+
+#include "database/Cluster.hpp"
+#include "database/Release.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "database/User.hpp"
+#include "utils/Logger.hpp"
+#include "SqlQuery.hpp"
+#include "Utils.hpp"
+#include "Traits.hpp"
+
+namespace Database
+{
+
+Artist::Artist(const std::string& name, const std::optional<UUID>& MBID)
+: _name {std::string(name, 0 , _maxNameLength)},
+_sortName {_name},
+_MBID {MBID ? MBID->getAsString() : ""}
+{
+}
+
+std::vector<Artist::pointer>
+Artist::getByName(Session& session, const std::string& name)
+{
+	session.checkSharedLocked();
+
+	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
+
+	return std::vector<Artist::pointer>(res.begin(), res.end());
+}
+
+Artist::pointer
+Artist::getByMBID(Session& session, const UUID& mbid)
+{
+	session.checkSharedLocked();
+	return session.getDboSession().find<Artist>().where("mbid = ?").bind(std::string {mbid.getAsString()}).resultValue();
+}
+
+Artist::pointer
+Artist::getById(Session& session, ArtistId id)
+{
+	session.checkSharedLocked();
+	return session.getDboSession().find<Artist>().where("id = ?").bind(id).resultValue();
+}
+
+bool
+Artist::exists(Session& session, ArtistId id)
+{
+	session.checkSharedLocked();
+	return session.getDboSession().query<int>("SELECT 1 FROM artist").where("id = ?").bind(id).resultValue() == 1;
+}
+
+Artist::pointer
+Artist::create(Session& session, const std::string& name, const std::optional<UUID>& MBID)
+{
+	session.checkUniqueLocked();
+
+	Artist::pointer res {session.getDboSession().add(std::make_unique<Artist>(name, MBID))};
+	session.getDboSession().flush();
+
+	return res;
+}
+
+template <typename T>
+static
+Wt::Dbo::Query<T>
+createQuery(Session& session,
+		const std::string& queryStr,
+		const std::vector<ClusterId>& clusterIds,
+		const std::vector<std::string_view>& keywords,
+		std::optional<TrackArtistLinkType> linkType)
+{
+	session.checkSharedLocked();
+
+	auto query {session.getDboSession().query<T>(queryStr)};
+	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");
+
+	if (linkType)
+		query.where("t_a_l.type = ?").bind(*linkType);
+
+	if (!keywords.empty())
+	{
+		std::vector<std::string> clauses;
+		std::vector<std::string> sortClauses;
+
+		for (std::string_view keyword : keywords)
+		{
+			clauses.push_back("a.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
+			query.bind("%" + escapeLikeKeyword(keyword) + "%");
+		}
+
+		for (std::string_view keyword : keywords)
+		{
+			sortClauses.push_back("a.sort_name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
+			query.bind("%" + escapeLikeKeyword(keyword) + "%");
+		}
+
+		query.where("(" + StringUtils::joinStrings(clauses, " AND ") + ") OR (" + StringUtils::joinStrings(sortClauses, " AND ") + ")");
+	}
+
+	if (!clusterIds.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";
+
+		WhereClause clusterClause;
+		for (const ClusterId clusterId : clusterIds)
+		{
+			clusterClause.Or(WhereClause("c.id = ?"));
+			query.bind(clusterId);
+		}
+
+		oss << " " << clusterClause.get();
+		oss << " GROUP BY t.id,a.id HAVING COUNT(DISTINCT c.id) = " << clusterIds.size() << ")";
+
+		query.where(oss.str());
+	}
+
+	return query;
+}
+
+std::vector<Artist::pointer>
+Artist::getAll(Session& session)
+{
+	session.checkSharedLocked();
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res = session.getDboSession().find<Artist>();
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<Artist::pointer>
+Artist::getAll(Session& session, SortMethod sortMethod)
+{
+	session.checkSharedLocked();
+
+	auto query {session.getDboSession().find<Artist>()};
+	switch (sortMethod)
+	{
+		case Artist::SortMethod::None:
+			break;
+		case Artist::SortMethod::ByName:
+			query.orderBy("name COLLATE NOCASE");
+			break;
+		case Artist::SortMethod::BySortName:
+			query.orderBy("sort_name COLLATE NOCASE");
+			break;
+	}
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res = query;
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+
+std::vector<Artist::pointer>
+Artist::getAll(Session& session, SortMethod sortMethod, std::optional<Range> range, bool& moreResults)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<Wt::Dbo::ptr<Artist>>(session, "SELECT a FROM Artist a", {}, {}, std::nullopt)};
+
+	switch (sortMethod)
+	{
+		case Artist::SortMethod::None:
+			break;
+		case Artist::SortMethod::ByName:
+			query.orderBy("a.name COLLATE NOCASE");
+			break;
+		case Artist::SortMethod::BySortName:
+			query.orderBy("a.sort_name COLLATE NOCASE");
+			break;
+	}
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection = query
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1);
+
+	std::vector<Artist::pointer> res (collection.begin(), collection.end());
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+std::vector<ArtistId>
+Artist::getAllIds(Session& session)
+{
+	session.checkSharedLocked();
+
+	Wt::Dbo::collection<ArtistId> res = session.getDboSession().query<ArtistId>("SELECT id FROM artist");
+	return std::vector<ArtistId>(res.begin(), res.end());
+}
+
+std::vector<ArtistId>
+Artist::getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<TrackArtistLinkType> linkType, std::optional<std::size_t> size)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<ArtistId>(session, "SELECT DISTINCT a.id from artist a", clusters, {}, linkType)};
+
+	Wt::Dbo::collection<ArtistId> res = query
+		.orderBy("RANDOM()")
+		.limit(size ? static_cast<int>(*size) : -1);
+
+	return std::vector<ArtistId>(res.begin(), res.end());
+
+}
+
+std::vector<Artist::pointer>
+Artist::getAllOrphans(Session& session)
+{
+	session.checkSharedLocked();
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res {session.getDboSession().query<Wt::Dbo::ptr<Artist>>("SELECT DISTINCT a 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)")};
+
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<ArtistId>
+Artist::getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit)
+{
+	session.checkSharedLocked();
+
+	Wt::Dbo::collection<ArtistId> res = session.getDboSession().query<ArtistId>
+		("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 track_cluster t_c ON t_c.track_id = t.id")
+		.limit(limit ? static_cast<int>(*limit) : -1);
+
+	return std::vector<ArtistId>(res.begin(), res.end());
+}
+
+std::vector<Artist::pointer>
+Artist::getByClusters(Session& session, const std::vector<ClusterId>& clusters, SortMethod sortMethod)
+{
+	assert(!clusters.empty());
+
+	session.checkSharedLocked();
+	bool more{};
+	return getByFilter(session, clusters, {}, std::nullopt, sortMethod, std::nullopt, more);
+}
+
+std::vector<Artist::pointer>
+Artist::getByFilter(Session& session,
+		const std::vector<ClusterId>& clusters,
+		const std::vector<std::string_view>& keywords,
+		std::optional<TrackArtistLinkType> linkType,
+		SortMethod sortMethod,
+		std::optional<Range> range,
+		bool& moreResults)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<Wt::Dbo::ptr<Artist>>(session, "SELECT DISTINCT a from artist a", clusters, keywords, linkType)};
+	switch (sortMethod)
+	{
+		case Artist::SortMethod::None:
+			break;
+		case Artist::SortMethod::ByName:
+			query.orderBy("a.name COLLATE NOCASE");
+			break;
+		case Artist::SortMethod::BySortName:
+			query.orderBy("a.sort_name COLLATE NOCASE");
+			break;
+	}
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection = query
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1);
+
+	std::vector<pointer> res (collection.begin(), collection.end());
+
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+std::vector<Artist::pointer>
+Artist::getLastWritten(Session& session,
+		std::optional<Wt::WDateTime> after,
+		const std::vector<ClusterId>& clusters,
+		std::optional<TrackArtistLinkType> linkType,
+		std::optional<Range> range, bool& moreResults)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<Wt::Dbo::ptr<Artist>>(session, "SELECT DISTINCT a from artist a", clusters, {}, linkType)};
+
+	if (after)
+		query.where("t.file_last_write > ?").bind(*after);
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection = query
+		.orderBy("t.file_last_write DESC")
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1);
+
+	std::vector<pointer> res (collection.begin(), collection.end());
+
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<Artist::pointer>
+Artist::getStarred(Session& session,
+		User::pointer user,
+		const std::vector<ClusterId>& clusters,
+		std::optional<TrackArtistLinkType> linkType,
+		SortMethod sortMethod,
+		std::optional<Range> range, bool& moreResults)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<Wt::Dbo::ptr<Artist>>(session, "SELECT DISTINCT a from artist a", clusters, {}, linkType)};
+
+	{
+		std::ostringstream oss;
+		oss << "a.id IN (SELECT DISTINCT a.id FROM artist a"
+			" INNER JOIN user_artist_starred uas ON uas.artist_id = a.id"
+			" INNER JOIN user u ON u.id = uas.user_id WHERE u.id = ?)";
+
+		query.bind(user->getId());
+		query.where(oss.str());
+	}
+
+	switch (sortMethod)
+	{
+		case Artist::SortMethod::None:
+			break;
+		case Artist::SortMethod::ByName:
+			query.orderBy("name COLLATE NOCASE");
+			break;
+		case Artist::SortMethod::BySortName:
+			query.orderBy("sort_name COLLATE NOCASE");
+			break;
+	}
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection = query
+		.groupBy("a.id")
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1);
+
+	std::vector<pointer> res (collection.begin(), collection.end());
+
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<Release::pointer>
+Artist::getReleases(const std::vector<ClusterId>& clusterIds) const
+{
+	assert(session());
+
+	WhereClause where;
+
+	std::ostringstream oss;
+
+	oss << "SELECT DISTINCT r 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";
+
+	if (!clusterIds.empty())
+	{
+		oss << " INNER JOIN cluster c ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
+
+		WhereClause clusterClause;
+
+		for (auto id : clusterIds)
+			clusterClause.Or(WhereClause("c.id = ?")).bind(id.toString());
+
+		where.And(clusterClause);
+	}
+
+	where.And(WhereClause("a.id = ?")).bind(getId().toString());
+
+	oss << " " << where.get();
+
+	if (!clusterIds.empty())
+		oss << " GROUP BY t.id HAVING COUNT(DISTINCT c.id) = " << clusterIds.size();
+
+	oss << " ORDER BY t.date DESC, r.name COLLATE NOCASE";
+
+	auto query {session()->query<Wt::Dbo::ptr<Release>>(oss.str())};
+
+	for (const std::string& bindArg : where.getBindArgs())
+		query.bind(bindArg);
+
+	auto res {query.resultList()};
+	return std::vector<Release::pointer>(res.begin(), res.end());
+}
+
+std::size_t
+Artist::getReleaseCount() const
+{
+	assert(session());
+
+	int res = session()->query<int>("SELECT COUNT(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 = ?").bind(getId());
+	return res;
+}
+
+std::vector<Track::pointer>
+Artist::getTracks(std::optional<TrackArtistLinkType> linkType) const
+{
+	assert(session());
+
+	auto query {session()->query<Wt::Dbo::ptr<Track>>("SELECT DISTINCT t FROM track t 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 = ?").bind(getId())
+		.orderBy("t.date DESC,t.release_id,t.disc_number,t.track_number")};
+
+	if (linkType)
+		query.where("t_a_l.type = ?").bind(*linkType);
+
+	auto tracks {query.resultList()};
+	return std::vector<Track::pointer>(tracks.begin(), tracks.end());
+}
+
+std::vector<Track::pointer>
+Artist::getNonReleaseTracks(std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const
+{
+	assert(session());
+
+	auto query {session()->query<Wt::Dbo::ptr<Track>>("SELECT t FROM track t 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 = ?").bind(getId())
+		.where("t.release_id is NULL")
+		.orderBy("t.name")
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1)};
+
+	if (linkType)
+		query.where("t_a_l.type = ?").bind(*linkType);
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<Track>> tracks {query.resultList()};
+	std::vector<Track::pointer> res(tracks.begin(), tracks.end());
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+bool
+Artist::hasNonReleaseTracks(std::optional<TrackArtistLinkType> linkType) const
+{
+	auto query {session()->query<Wt::Dbo::ptr<Track>>("SELECT t FROM track t 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 = ?").bind(getId())
+		.where("t.release_id is NULL")
+		.orderBy("t.name")};
+
+	if (linkType)
+		query.where("t_a_l.type = ?").bind(*linkType);
+
+	return !query.resultList().empty();
+}
+
+std::vector<Track::pointer>
+Artist::getRandomTracks(std::optional<std::size_t> count) const
+{
+	assert(session());
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<Track>> tracks {session()->query<Wt::Dbo::ptr<Track>>("SELECT t from track t 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 = ?").bind(getId())
+		.orderBy("RANDOM()")
+		.limit(count ? static_cast<int>(*count) : -1)};
+
+	return std::vector<Track::pointer>(tracks.begin(), tracks.end());
+}
+
+std::vector<Artist::pointer>
+Artist::getSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes, std::optional<Range> range) const
+{
+	assert(session());
+
+	std::ostringstream oss;
+	oss <<
+			"SELECT a 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 <> ?";
+
+	if (!artistLinkTypes.empty())
+	{
+		oss << " AND t_a_l.type IN (";
+
+		bool first {true};
+		for (TrackArtistLinkType type : artistLinkTypes)
+		{
+			(void) type;
+			if (!first)
+				oss << ", ";
+			oss << "?";
+			first = false;
+		}
+		oss << ")";
+	}
+
+	Wt::Dbo::Query<Wt::Dbo::ptr<Artist>> query {session()->query<Wt::Dbo::ptr<Artist>>(oss.str())
+		.bind(getId())
+		.bind(getId())
+		.groupBy("a.id")
+		.orderBy("COUNT(*) DESC, RANDOM()")
+		.limit(range ? static_cast<int>(range->limit) : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1)};
+
+	for (TrackArtistLinkType type : artistLinkTypes)
+		query.bind(type);
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res {query.resultList()};
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<std::vector<Cluster::pointer>>
+Artist::getClusterGroups(std::vector<ClusterType::pointer> clusterTypes, std::size_t size) const
+{
+	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 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";
+
+	where.And(WhereClause("a.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(DISTINCT c.id) DESC";
+
+	Wt::Dbo::Query<Wt::Dbo::ptr<Cluster>> query = session()->query<Wt::Dbo::ptr<Cluster>>( oss.str() );
+
+	for (const std::string& bindArg : where.getBindArgs())
+		query.bind(bindArg);
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> queryRes = query;
+
+	std::map<ClusterTypeId, std::vector<Cluster::pointer>> clustersByType;
+	for (const 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

src/libs/services/database/impl/Cluster.cpp

@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2013-2016 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 "database/Cluster.hpp"
+
+#include "database/Artist.hpp"
+#include "database/Release.hpp"
+#include "database/ScanSettings.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "SqlQuery.hpp"
+#include "Traits.hpp"
+
+namespace Database {
+
+Cluster::Cluster(ObjectPtr<ClusterType> type, std::string_view name)
+	: _name {std::string {name, 0, _maxNameLength}},
+	_clusterType {getDboPtr(type)}
+{
+}
+
+Cluster::pointer
+Cluster::create(Session& session, ObjectPtr<ClusterType> type, std::string_view name)
+{
+	session.checkUniqueLocked();
+
+	Cluster::pointer res {session.getDboSession().add(std::make_unique<Cluster>(type, name))};
+	session.getDboSession().flush();
+
+	return res;
+}
+
+std::vector<Cluster::pointer>
+Cluster::getAll(Session& session)
+{
+	session.checkSharedLocked();
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> res {session.getDboSession().find<Cluster>()};
+	return std::vector<Cluster::pointer>(res.begin(), res.end());
+}
+
+std::vector<Cluster::pointer>
+Cluster::getAllOrphans(Session& session)
+{
+	session.checkSharedLocked();
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Cluster>>("SELECT DISTINCT c FROM cluster c WHERE NOT EXISTS(SELECT 1 FROM track_cluster t_c WHERE t_c.cluster_id = c.id)").resultList()};
+	return std::vector<Cluster::pointer>(res.begin(), res.end());
+}
+
+Cluster::pointer
+Cluster::getById(Session& session, ClusterId id)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().find<Cluster>().where("id = ?").bind(id).resultValue();
+}
+
+void
+Cluster::addTrack(ObjectPtr<Track> track)
+{
+	_tracks.insert(getDboPtr(track));
+}
+
+std::vector<Track::pointer>
+Cluster::getTracks(std::optional<std::size_t> offset, std::optional<std::size_t> limit) const
+{
+	assert(session());
+
+	auto res {session()->query<Wt::Dbo::ptr<Track>>("SELECT t FROM track t INNER JOIN cluster c ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
+			.where("c.id = ?").bind(getId())
+			.offset(offset ? static_cast<int>(*offset) : -1)
+			.limit(limit ? static_cast<int>(*limit) : -1)
+			.resultList()};
+
+	return std::vector<Track::pointer>(res.begin(), res.end());
+}
+
+std::vector<TrackId>
+Cluster::getTrackIds() const
+{
+	assert(session());
+
+	Wt::Dbo::collection<TrackId> res = session()->query<TrackId>("SELECT t_c.track_id FROM track_cluster t_c INNER JOIN cluster c ON c.id = t_c.cluster_id")
+		.where("c.id = ?").bind(getId());
+
+	return std::vector<TrackId>(res.begin(), res.end());
+}
+
+std::size_t
+Cluster::getReleasesCount() const
+{
+	assert(session());
+
+	return session()->query<int>("SELECT COUNT(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")
+		.where("c.id = ?").bind(getId());
+}
+
+
+ClusterType::ClusterType(std::string_view name)
+	: _name {name}
+{
+}
+
+std::vector<ClusterType::pointer>
+ClusterType::getAllOrphans(Session& session)
+{
+	session.checkSharedLocked();
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<ClusterType>> res = session.getDboSession().query<Wt::Dbo::ptr<ClusterType>>(
+			"SELECT c_t from cluster_type c_t"
+			" LEFT OUTER JOIN cluster c ON c_t.id = c.cluster_type_id")
+		.where("c.id IS NULL");
+
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<ClusterType::pointer>
+ClusterType::getAllUsed(Session& session)
+{
+	session.checkSharedLocked();
+
+	Wt::Dbo::collection<Wt::Dbo::ptr<ClusterType>> res = session.getDboSession().query<Wt::Dbo::ptr<ClusterType>>(
+			"SELECT DISTINCT c_t from cluster_type c_t")
+		.join("cluster c ON c_t.id = c.cluster_type_id");
+
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+ClusterType::pointer
+ClusterType::getByName(Session& session, const std::string& name)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().find<ClusterType>().where("name = ?").bind(name).resultValue();
+}
+
+ClusterType::pointer
+ClusterType::getById(Session& session, ClusterTypeId id)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().find<ClusterType>().where("id = ?").bind(id).resultValue();
+}
+
+std::vector<ClusterType::pointer>
+ClusterType::getAll(Session& session)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().find<ClusterType>().resultList()};
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+ClusterType::pointer
+ClusterType::create(Session& session, const std::string& name)
+{
+	session.checkUniqueLocked();
+
+	ClusterType::pointer res {session.getDboSession().add(std::make_unique<ClusterType>(name))};
+	session.getDboSession().flush();
+
+	return res;
+}
+
+Cluster::pointer
+ClusterType::getCluster(const std::string& name) const
+{
+	assert(self());
+	assert(session());
+
+	return session()->find<Cluster>()
+		.where("name = ?").bind(name)
+		.where("cluster_type_id = ?").bind(getId()).resultValue();
+}
+
+std::vector<Cluster::pointer>
+ClusterType::getClusters() const
+{
+	assert(self());
+	assert(session());
+
+	auto res = session()->find<Cluster>()
+						.where("cluster_type_id = ?").bind(getId())
+						.orderBy("name")
+						.resultList();
+
+	return std::vector<Cluster::pointer>(res.begin(), res.end());
+}
+
+
+} // namespace Database
+

src/libs/services/database/impl/Db.cpp

@@ -0,0 +1,98 @@
+/*
+ * 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/>.
+ */
+
+#include "database/Db.hpp"
+
+#include <Wt/Dbo/FixedSqlConnectionPool.h>
+#include <Wt/Dbo/backend/Sqlite3.h>
+
+#include "database/Session.hpp"
+#include "database/User.hpp"
+#include "utils/Logger.hpp"
+
+namespace Database {
+
+// Session living class handling the database and the login
+Db::Db(const std::filesystem::path& dbPath, std::size_t connectionCount)
+{
+	LMS_LOG(DB, INFO) << "Creating connection pool on file " << dbPath.string();
+
+	std::unique_ptr<Wt::Dbo::backend::Sqlite3> connection {std::make_unique<Wt::Dbo::backend::Sqlite3>(dbPath.string())};
+//	connection->setProperty("show-queries", "true");
+	connection->executeSql("pragma journal_mode=WAL");
+	connection->executeSql("pragma synchronous=normal");
+
+	auto connectionPool = std::make_unique<Wt::Dbo::FixedSqlConnectionPool>(std::move(connection), connectionCount);
+	connectionPool->setTimeout(std::chrono::seconds(10));
+
+	_connectionPool = std::move(connectionPool);
+}
+
+Db::~Db()
+{
+	LMS_LOG(DB, DEBUG) << "Optimizing db...";
+	executeSql("pragma optimize");
+	LMS_LOG(DB, DEBUG) << "Optimizing db DONE";
+}
+
+void
+Db::executeSql(const std::string& sql)
+{
+	ScopedConnection connection {*_connectionPool};
+	connection->executeSql(sql);
+}
+
+Session&
+Db::getTLSSession()
+{
+	static thread_local Session* tlsSession {};
+
+	if (!tlsSession)
+	{
+		auto newSession {std::make_unique<Session>(*this)};
+		tlsSession = newSession.get();
+
+		{
+			std::scoped_lock lock {_tlsSessionsMutex};
+			_tlsSessions.push_back(std::move(newSession));
+		}
+	}
+
+	return *tlsSession;
+}
+
+Db::ScopedConnection::ScopedConnection(Wt::Dbo::SqlConnectionPool& pool)
+: _connectionPool {pool}
+, _connection {_connectionPool.getConnection()}
+{
+}
+
+Db::ScopedConnection::~ScopedConnection()
+{
+	_connectionPool.returnConnection(std::move(_connection));
+}
+
+Wt::Dbo::SqlConnection* Db::ScopedConnection::operator->() const
+{
+	return _connection.get();
+}
+
+} // namespace Database
+
+

src/libs/services/database/impl/Release.cpp

@@ -0,0 +1,625 @@
+/*
+ * Copyright (C) 2015 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 "database/Release.hpp"
+
+#include <Wt/Dbo/WtSqlTraits.h>
+
+#include "database/Artist.hpp"
+#include "database/Cluster.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "database/User.hpp"
+#include "utils/Logger.hpp"
+#include "SqlQuery.hpp"
+#include "Traits.hpp"
+#include "Utils.hpp"
+
+namespace Database
+{
+
+template <typename T>
+static
+Wt::Dbo::Query<T>
+createQuery(Session& session,
+			const std::string& queryStr,
+			const std::vector<ClusterId>& clusterIds,
+			const std::vector<std::string_view>& keywords)
+{
+
+	auto query {session.getDboSession().query<T>(queryStr)};
+	query.join("track t ON t.release_id = r.id");
+
+	for (std::string_view keyword : keywords)
+		query.where("r.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'").bind("%" + escapeLikeKeyword(keyword) + "%");
+
+	if (!clusterIds.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";
+
+		WhereClause clusterClause;
+		for (const ClusterId clusterId : clusterIds)
+		{
+			clusterClause.Or(WhereClause("c.id = ?"));
+			query.bind(clusterId);
+		}
+
+		oss << " " << clusterClause.get();
+		oss << " GROUP BY t.id HAVING COUNT(*) = " << clusterIds.size() << ")";
+
+		query.where(oss.str());
+	}
+
+	return query;
+}
+
+Release::Release(const std::string& name, const std::optional<UUID>& MBID)
+: _name {std::string(name, 0 , _maxNameLength)},
+_MBID {MBID ? MBID->getAsString() : ""}
+{
+}
+
+std::vector<Release::pointer>
+Release::getByName(Session& session, const std::string& name)
+{
+	session.checkUniqueLocked();
+
+	auto res {session.getDboSession()
+						.find<Release>()
+						.where("name = ?").bind( std::string(name, 0, _maxNameLength) )
+						.resultList()};
+
+	return std::vector<Release::pointer>(res.begin(), res.end());
+}
+
+Release::pointer
+Release::getByMBID(Session& session, const UUID& mbid)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession()
+					.find<Release>()
+					.where("mbid = ?").bind(std::string {mbid.getAsString()})
+					.resultValue();;
+}
+
+Release::pointer
+Release::getById(Session& session, ReleaseId id)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession()
+					.find<Release>()
+					.where("id = ?").bind(id)
+					.resultValue();
+}
+
+bool
+Release::exists(Session& session, ReleaseId id)
+{
+	session.checkSharedLocked();
+	return session.getDboSession().query<int>("SELECT 1 FROM release").where("id = ?").bind(id).resultValue() == 1;
+}
+
+Release::pointer
+Release::create(Session& session, const std::string& name, const std::optional<UUID>& MBID)
+{
+	session.checkSharedLocked();
+
+	Release::pointer res {session.getDboSession().add(std::make_unique<Release>(name, MBID))};
+	session.getDboSession().flush();
+
+	return res;
+}
+
+std::size_t
+Release::getCount(Session& session)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().find<Release>().resultList().size();
+}
+
+std::vector<Release::pointer>
+Release::getAll(Session& session, std::optional<Range> range)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().find<Release>()
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.limit(range ? static_cast<int>(range->limit) : -1)
+		.orderBy("name COLLATE NOCASE")
+		.resultList()};
+
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<ReleaseId>
+Release::getAllIds(Session& session)
+{
+	session.checkSharedLocked();
+
+	Wt::Dbo::collection<ReleaseId> res = session.getDboSession().query<ReleaseId>("SELECT id FROM release");
+	return std::vector<ReleaseId>(res.begin(), res.end());
+}
+
+std::vector<Release::pointer>
+Release::getAllOrderedByArtist(Session& session, std::optional<std::size_t> offset, std::optional<std::size_t> size)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Release>>(
+			"SELECT DISTINCT r FROM release r"
+			" INNER JOIN track t ON r.id = t.release_id"
+			" INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id"
+			" INNER JOIN artist a ON t_a_l.artist_id = a.id")
+		 .offset(offset ? static_cast<int>(*offset) : -1)
+		 .limit(size ? static_cast<int>(*size) : -1)
+		 .orderBy("a.name COLLATE NOCASE, r.name COLLATE NOCASE")
+		 .resultList()};
+
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<Release::pointer>
+Release::getAllRandom(Session& session, const std::vector<ClusterId>& clusterIds, std::optional<std::size_t> size)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<Wt::Dbo::ptr<Release>>(session, "SELECT DISTINCT r from release r", clusterIds, {})};
+	auto res {query
+		.orderBy("RANDOM()")
+		.limit(size ? static_cast<int>(*size) : -1)
+		.resultList()};
+
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<ReleaseId>
+Release::getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusterIds, std::optional<std::size_t> size)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<ReleaseId>(session, "SELECT DISTINCT r.id from release r", clusterIds, {})};
+
+	Wt::Dbo::collection<ReleaseId> res = query
+		.orderBy("RANDOM()")
+		.limit(size ? static_cast<int>(*size) : -1);
+
+	return std::vector<ReleaseId>(res.begin(), res.end());
+}
+
+
+std::vector<Release::pointer>
+Release::getAllOrphans(Session& session)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Release>>("select r from release r LEFT OUTER JOIN Track t ON r.id = t.release_id WHERE t.id IS NULL").resultList()};
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<Release::pointer>
+Release::getLastWritten(Session& session,
+		std::optional<Wt::WDateTime> after,
+		const std::vector<ClusterId>& clusterIds,
+		std::optional<Range> range,
+		bool& moreResults)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<Wt::Dbo::ptr<Release>>(session, "SELECT r from release r", clusterIds, {})};
+	if (after)
+		query.where("t.file_last_write > ?").bind(after);
+
+	auto collection {query
+		.orderBy("t.file_last_write DESC")
+		.groupBy("r.id")
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.limit(range ? static_cast<int>(range->limit) + 1: -1)
+		.resultList()};
+
+	std::vector<pointer> res(collection.begin(), collection.end());
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+std::vector<Release::pointer>
+Release::getByYear(Session& session, int yearFrom, int yearTo, std::optional<Range> range)
+{
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Release>>
+		("SELECT DISTINCT r from release r INNER JOIN track t ON r.id = t.release_id")
+		.where("t.date >= ?").bind(Wt::WDate {yearFrom, 1, 1})
+		.where("t.date <= ?").bind(Wt::WDate {yearTo, 12, 31})
+		.orderBy("t.date, r.name COLLATE NOCASE")
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.limit(range ? static_cast<int>(range->limit) : -1)
+		.resultList()};
+
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<Release::pointer>
+Release::getStarred(Session& session,
+		User::pointer user,
+		const std::vector<ClusterId>& clusterIds,
+		std::optional<Range> range,
+		bool& moreResults)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<Wt::Dbo::ptr<Release>>(session, "SELECT r from release r", clusterIds, {})};
+	{
+		std::ostringstream oss;
+		oss << "r.id IN (SELECT DISTINCT r.id FROM release r"
+			" INNER JOIN user_release_starred urs ON urs.release_id = r.id"
+			" INNER JOIN user u ON u.id = urs.user_id WHERE u.id = ?)";
+
+		query.bind(user->getId());
+		query.where(oss.str());
+	}
+
+	auto collection {query
+		.groupBy("r.id")
+		.orderBy("r.name COLLATE NOCASE")
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.limit(range ? static_cast<int>(range->limit) + 1: -1)
+		.resultList()};
+
+	std::vector<pointer> res(collection.begin(), collection.end());
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+
+
+}
+
+std::vector<Release::pointer>
+Release::getByClusters(Session& session, const std::vector<ClusterId>& clusters)
+{
+	assert(!clusters.empty());
+
+	session.checkSharedLocked();
+
+	bool moreResults;
+	return getByFilter(session, clusters, {}, std::nullopt, moreResults);
+}
+
+std::vector<Release::pointer>
+Release::getByFilter(Session& session,
+		const std::vector<ClusterId>& clusterIds,
+		const std::vector<std::string_view>& keywords,
+		std::optional<Range> range,
+		bool& moreResults)
+{
+	session.checkSharedLocked();
+
+	auto collection {createQuery<Wt::Dbo::ptr<Release>>(session, "SELECT r from release r", clusterIds, keywords)
+		.groupBy("r.id")
+		.orderBy("r.name COLLATE NOCASE")
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
+
+	std::vector<pointer> res(collection.begin(), collection.end());
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+std::vector<ReleaseId>
+Release::getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit)
+{
+	session.checkSharedLocked();
+
+	Wt::Dbo::collection<ReleaseId> res = session.getDboSession().query<ReleaseId>
+		("SELECT DISTINCT r.id 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")
+		.limit(limit ? static_cast<int>(*limit) : -1);
+
+	return std::vector<ReleaseId>(res.begin(), res.end());
+}
+
+
+std::optional<std::size_t>
+Release::getTotalTrack(void) const
+{
+	assert(session());
+
+	int res = session()->query<int>("SELECT COALESCE(MAX(total_track),0) FROM track t INNER JOIN release r ON r.id = t.release_id")
+		.where("r.id = ?")
+		.bind(getId());
+
+	return (res > 0) ? std::make_optional<std::size_t>(res) : std::nullopt;
+}
+
+std::optional<std::size_t>
+Release::getTotalDisc(void) const
+{
+	assert(session());
+
+	int res = session()->query<int>("SELECT COALESCE(MAX(total_disc),0) FROM track t INNER JOIN release r ON r.id = t.release_id")
+		.where("r.id = ?")
+		.bind(getId());
+
+	return (res > 0) ? std::make_optional<std::size_t>(res) : std::nullopt;
+}
+
+std::optional<int>
+Release::getReleaseYear(bool original) const
+{
+	assert(session());
+
+	const char* field {original ? "original_date" : "date"};
+
+	auto dates {session()->query<Wt::WDate>(
+			std::string {"SELECT "} + "t." + field + " FROM track t INNER JOIN release r ON r.id = t.release_id")
+		.where("r.id = ?")
+		.groupBy(field)
+		.bind(getId())
+		.resultList()};
+
+	// various dates => no date
+	if (dates.empty() || dates.size() > 1)
+		return std::nullopt;
+
+	auto date {dates.front().year()};
+
+	if (date > 0)
+		return date;
+
+	return std::nullopt;
+}
+
+std::optional<std::string>
+Release::getCopyright() const
+{
+	assert(session());
+
+	Wt::Dbo::collection<std::string> copyrights = session()->query<std::string>
+		("SELECT copyright FROM track t INNER JOIN release r ON r.id = t.release_id")
+		.where("r.id = ?")
+		.groupBy("copyright")
+		.bind(getId());
+
+	std::vector<std::string> values(copyrights.begin(), copyrights.end());
+
+	// various copyrights => no copyright
+	if (values.empty() || values.size() > 1 || values.front().empty())
+		return std::nullopt;
+
+	return values.front();
+}
+
+std::optional<std::string>
+Release::getCopyrightURL() const
+{
+	assert(session());
+
+	Wt::Dbo::collection<std::string> copyrights = session()->query<std::string>
+		("SELECT copyright_url FROM track t INNER JOIN release r ON r.id = t.release_id")
+		.where("r.id = ?")
+		.groupBy("copyright_url")
+		.bind(getId());
+
+	std::vector<std::string> values(copyrights.begin(), copyrights.end());
+
+	// various copyright URLs => no copyright URL
+	if (values.empty() || values.size() > 1 || values.front().empty())
+		return std::nullopt;
+
+	return values.front();
+}
+
+std::vector<Artist::pointer>
+Release::getArtists(TrackArtistLinkType linkType) const
+{
+	assert(session());
+
+	auto res {session()->query<Wt::Dbo::ptr<Artist>>(
+			"SELECT DISTINCT a 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 release r ON r.id = t.release_id")
+		.where("r.id = ?").bind(getId())
+		.where("t_a_l.type = ?").bind(linkType)
+		.resultList()};
+
+	return std::vector<Artist::pointer>(res.begin(), res.end());
+}
+
+std::vector<Release::pointer>
+Release::getSimilarReleases(std::optional<std::size_t> offset, std::optional<std::size_t> count) const
+{
+	assert(session());
+
+	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 = ?)"
+					" AND r.id <> ?"
+				)
+		.bind(getId())
+		.bind(getId())
+		.groupBy("r.id")
+		.orderBy("COUNT(*) DESC, RANDOM()")
+		.limit(count ? static_cast<int>(*count) : -1)
+		.offset(offset ? static_cast<int>(*offset) : -1)
+		.resultList()};
+
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+bool
+Release::hasVariousArtists() const
+{
+	// TODO optimize
+	return getArtists().size() > 1;
+}
+
+std::vector<Track::pointer>
+Release::getTracks(const std::vector<ClusterId>& clusterIds) const
+{
+	assert(session());
+
+	WhereClause where;
+
+	std::ostringstream oss;
+	oss << "SELECT t FROM track t INNER JOIN release r ON t.release_id = r.id";
+
+	if (!clusterIds.empty())
+	{
+		oss << " INNER JOIN cluster c ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
+
+		WhereClause clusterClause;
+
+		for (auto id : clusterIds)
+			clusterClause.Or(WhereClause("c.id = ?")).bind(id.toString());
+
+		where.And(clusterClause);
+	}
+
+	where.And(WhereClause("r.id = ?")).bind(getId().toString());
+
+	oss << " " << where.get();
+
+	if (!clusterIds.empty())
+		oss << " GROUP BY t.id HAVING COUNT(*) = " << clusterIds.size();
+
+	oss << " ORDER BY t.disc_number,t.track_number";
+
+	auto query {session()->query<Wt::Dbo::ptr<Track>>(oss.str())};
+	for (const std::string& bindArg : where.getBindArgs())
+		query.bind(bindArg);
+
+	auto res {query.resultList()};
+	return std::vector<Track::pointer> (res.begin(), res.end());
+}
+
+std::size_t
+Release::getTracksCount() const
+{
+	return _tracks.size();
+}
+
+Track::pointer
+Release::getFirstTrack() const
+{
+	assert(session());
+
+	return session()->query<Wt::Dbo::ptr<Track>>("SELECT t from track t")
+		.join("release r ON t.release_id = r.id")
+		.where("r.id = ?").bind(getId())
+		.orderBy("t.disc_number,t.track_number")
+		.limit(1)
+		.resultValue();
+}
+
+std::chrono::milliseconds
+Release::getDuration() const
+{
+	assert(session());
+
+	using milli = std::chrono::duration<int, std::milli>;
+
+	Wt::Dbo::Query<milli> query {session()->query<milli>("SELECT COALESCE(SUM(duration), 0) FROM track t INNER JOIN release r ON t.release_id = r.id")
+			.where("r.id = ?").bind(getId())};
+
+	return query.resultValue();
+}
+
+Wt::WDateTime
+Release::getLastWritten() const
+{
+	assert(session());
+
+	Wt::Dbo::Query<Wt::WDateTime> query {session()->query<Wt::WDateTime>("SELECT COALESCE(MAX(file_last_write), '1970-01-01T00:00:00') FROM track t INNER JOIN release r ON t.release_id = r.id")
+			.where("r.id = ?").bind(getId())};
+
+	return query.resultValue();
+}
+
+std::vector<std::vector<Cluster::pointer>>
+Release::getClusterGroups(const std::vector<ClusterType::pointer>& clusterTypes, std::size_t size) const
+{
+	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 INNER JOIN release r ON t.release_id = r.id ";
+
+	where.And(WhereClause("r.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>> clustersByType;
+	for (const Wt::Dbo::ptr<Cluster>& 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;
+}
+
+} // namespace Database

src/libs/services/database/impl/ScanSettings.cpp

@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2018 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 "database/ScanSettings.hpp"
+
+#include <Wt/Dbo/WtSqlTraits.h>
+
+#include "utils/Path.hpp"
+#include "utils/Logger.hpp"
+#include "utils/String.hpp"
+
+#include "database/Cluster.hpp"
+#include "database/Session.hpp"
+
+namespace {
+
+const std::set<std::string> defaultClusterTypeNames =
+{
+	"GENRE",
+	"ALBUMGROUPING",
+	"MOOD",
+	"ALBUMMOOD",
+};
+
+}
+
+namespace Database {
+
+void
+ScanSettings::init(Session& session)
+{
+	session.checkUniqueLocked();
+
+	pointer settings {get(session)};
+	if (settings)
+		return;
+
+	settings = session.getDboSession().add(std::make_unique<ScanSettings>());
+	settings.modify()->setClusterTypes(session, defaultClusterTypeNames );
+}
+
+ScanSettings::pointer
+ScanSettings::get(Session& session)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().find<ScanSettings>().resultValue();
+}
+
+std::vector<std::filesystem::path>
+ScanSettings::getAudioFileExtensions() const
+{
+	const auto extensions {StringUtils::splitString(_audioFileExtensions, " ")};
+	return std::vector<std::filesystem::path>(std::cbegin(extensions), std::cend(extensions));
+}
+
+void
+ScanSettings::addAudioFileExtension(const std::filesystem::path& ext)
+{
+	_audioFileExtensions += " " + ext.string();
+}
+
+std::vector<ClusterType::pointer>
+ScanSettings::getClusterTypes() const
+{
+	return std::vector<ClusterType::pointer>(std::cbegin(_clusterTypes), std::cend(_clusterTypes));
+}
+
+void
+ScanSettings::setMediaDirectory(const std::filesystem::path& p)
+{
+	_mediaDirectory = StringUtils::stringTrimEnd(p.string(), "/\\");
+}
+
+template <typename It>
+std::set<std::string> getNames(It begin, It end)
+{
+	std::set<std::string> names;
+	std::transform(begin, end, std::inserter(names, std::cbegin(names)),
+		[](const ClusterType::pointer& clusterType)
+		{
+			return clusterType->getName();
+		});
+
+	return names;
+}
+
+void
+ScanSettings::setClusterTypes(Session& session, const std::set<std::string>& clusterTypeNames)
+{
+	session.checkUniqueLocked();
+
+	bool needRescan {};
+
+	// Create any missing cluster type
+	for (const std::string& clusterTypeName : clusterTypeNames)
+	{
+		ClusterType::pointer clusterType {ClusterType::getByName(session, clusterTypeName)};
+		if (!clusterType)
+		{
+			LMS_LOG(DB, INFO) << "Creating cluster type " << clusterTypeName;
+			clusterType = ClusterType::create(session, clusterTypeName);
+			_clusterTypes.insert(getDboPtr(clusterType));
+
+			needRescan = true;
+		}
+	}
+
+	// Delete no longer existing cluster types
+	for (Wt::Dbo::ptr<ClusterType> clusterType : _clusterTypes)
+	{
+		if (std::none_of(clusterTypeNames.begin(), clusterTypeNames.end(),
+			[clusterType](const std::string& name) { return name == clusterType->getName(); }))
+		{
+			LMS_LOG(DB, INFO) << "Deleting cluster type " << clusterType->getName();
+			clusterType.remove();
+		}
+	}
+
+	if (needRescan)
+		_scanVersion += 1;
+}
+
+void
+ScanSettings::incScanVersion()
+{
+	_scanVersion += 1;
+}
+
+} // namespace Database
+

src/libs/services/database/impl/Session.cpp

@@ -0,0 +1,508 @@
+/*
+ * Copyright (C) 2020 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 "database/Session.hpp"
+
+#include <map>
+#include <mutex>
+#include <thread>
+#include <string_view>
+
+#include "utils/Exception.hpp"
+#include "utils/Logger.hpp"
+
+#include "database/Artist.hpp"
+#include "database/Cluster.hpp"
+#include "database/Db.hpp"
+#include "database/Release.hpp"
+#include "database/ScanSettings.hpp"
+#include "database/Track.hpp"
+#include "database/TrackBookmark.hpp"
+#include "database/TrackArtistLink.hpp"
+#include "database/TrackList.hpp"
+#include "database/TrackFeatures.hpp"
+#include "database/User.hpp"
+
+namespace Database
+{
+
+	using Version = std::size_t;
+	static constexpr Version LMS_DATABASE_VERSION {31};
+
+	class VersionInfo
+	{
+		public:
+			using pointer = Wt::Dbo::ptr<VersionInfo>;
+
+			static VersionInfo::pointer getOrCreate(Session& session)
+			{
+			session.checkUniqueLocked();
+
+			pointer versionInfo {session.getDboSession().find<VersionInfo>()};
+			if (!versionInfo)
+				return session.getDboSession().add(std::make_unique<VersionInfo>());
+
+			return versionInfo;
+		}
+
+		static VersionInfo::pointer get(Session& session)
+		{
+			session.checkSharedLocked();
+
+			return session.getDboSession().find<VersionInfo>();
+		}
+
+		Version getVersion() const { return _version; }
+		void setVersion(Version version) { _version = static_cast<int>(version); }
+
+		template<class Action>
+		void persist(Action& a)
+		{
+			Wt::Dbo::field(a, _version, "db_version");
+		}
+
+	private:
+		int _version {LMS_DATABASE_VERSION};
+	};
+
+void
+Session::doDatabaseMigrationIfNeeded()
+{
+	static const std::string outdatedMsg {"Outdated database, please rebuild it (delete the .db file and restart)"};
+
+	Db::ScopedNoForeignKeys noPragmaKeys {_db};
+
+	while (1)
+	{
+		auto uniqueTransaction {createUniqueTransaction()};
+
+		Version version;
+		try
+		{
+			version = VersionInfo::getOrCreate(*this)->getVersion();
+			LMS_LOG(DB, INFO) << "Database version = " << version << ", LMS binary version = " << LMS_DATABASE_VERSION;
+			if (version == LMS_DATABASE_VERSION)
+			{
+				LMS_LOG(DB, DEBUG) << "Lms database version " << LMS_DATABASE_VERSION << ": up to date!";
+				return;
+			}
+		}
+		catch (std::exception& e)
+		{
+			LMS_LOG(DB, ERROR) << "Cannot get database version info: " << e.what();
+			throw LmsException {outdatedMsg};
+		}
+
+		LMS_LOG(DB, INFO) << "Migrating database from version " << version << "...";
+
+		if (version == 5)
+		{
+			_session.execute("DELETE FROM auth_token"); // format has changed
+		}
+		else if (version == 6)
+		{
+			// Just increment the scan version of the settings to make the next scheduled scan rescan everything
+			ScanSettings::get(*this).modify()->incScanVersion();
+		}
+		else if (version == 7)
+		{
+			_session.execute("DROP TABLE similarity_settings");
+			_session.execute("DROP TABLE similarity_settings_feature");
+			_session.execute("ALTER TABLE scan_settings ADD similarity_engine_type INTEGER NOT NULL DEFAULT(" + std::to_string(static_cast<int>(ScanSettings::RecommendationEngineType::Clusters)) + ")");
+		}
+		else if (version == 8)
+		{
+			// 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(*this).modify()->incScanVersion();
+		}
+		else if (version == 9)
+		{
+			_session.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
+);)");
+		}
+		else if (version == 10)
+		{
+			ScanSettings::get(*this).modify()->addAudioFileExtension(".m4b");
+			ScanSettings::get(*this).modify()->addAudioFileExtension(".alac");
+		}
+		else if (version == 11)
+		{
+			// 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(*this).modify()->incScanVersion();
+		}
+		else if (version == 12)
+		{
+			// 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(*this).modify()->incScanVersion();
+		}
+		else if (version == 13)
+		{
+			// 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(*this).modify()->incScanVersion();
+		}
+		else if (version == 14)
+		{
+			// SortName now set from metadata
+			// Just increment the scan version of the settings to make the next scheduled scan rescan everything
+			ScanSettings::get(*this).modify()->incScanVersion();
+		}
+		else if (version == 15)
+		{
+			_session.execute("ALTER TABLE user ADD ui_theme INTEGER NOT NULL DEFAULT(" + std::to_string(static_cast<int>(User::defaultUITheme)) + ")");
+		}
+		else if (version == 16)
+		{
+			_session.execute("ALTER TABLE track ADD total_disc INTEGER NOT NULL DEFAULT(0)");
+			_session.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(*this).modify()->incScanVersion();
+		}
+		else if (version == 17)
+		{
+			// Drop colums total_disc/total_track from release
+			_session.execute(R"(
+CREATE TABLE "release_backup" (
+  "id" integer primary key autoincrement,
+  "version" integer not null,
+  "name" text not null,
+  "mbid" text not null
+))");
+			_session.execute("INSERT INTO release_backup SELECT id,version,name,mbid FROM release");
+			_session.execute("DROP TABLE release");
+			_session.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(*this).modify()->incScanVersion();
+		}
+		else if (version == 18)
+		{
+			_session.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
+))");
+		}
+		else if (version == 19)
+		{
+			_session.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.execute(std::string {"INSERT INTO user_backup SELECT id, version, type, login_name, password_salt, password_hash, last_login, "}
+					+ (User::defaultSubsonicTranscodeEnable ? "1" : "0")
+					+ ", " + 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.execute("DROP TABLE user");
+			_session.execute("ALTER TABLE user_backup RENAME TO user");
+		}
+		else if (version == 20)
+		{
+			_session.execute("DROP TABLE subsonic_settings");
+		}
+		else if (version == 21)
+		{
+			_session.execute("ALTER TABLE track ADD track_replay_gain REAL");
+			_session.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(*this).modify()->incScanVersion();
+		}
+		else if (version == 22)
+		{
+			_session.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(*this).modify()->incScanVersion();
+		}
+		else if (version == 23)
+		{
+			// Better cover detection
+			// Just increment the scan version of the settings to make the next scheduled scan rescan everything
+			ScanSettings::get(*this).modify()->incScanVersion();
+		}
+		else if (version == 24)
+		{
+			// User's AuthMode
+			_session.execute("ALTER TABLE user ADD auth_mode INTEGER NOT NULL DEFAULT(" + std::to_string(static_cast<int>(/*User::defaultAuthMode*/0)) + ")");
+		}
+		else if (version == 25)
+		{
+			// Better cover detection
+			// Just increment the scan version of the settings to make the next scheduled scan rescan everything
+			ScanSettings::get(*this).modify()->incScanVersion();
+		}
+		else if (version == 26)
+		{
+			// Composer, mixer, etc. support
+			// Just increment the scan version of the settings to make the next scheduled scan rescan everything
+			ScanSettings::get(*this).modify()->incScanVersion();
+		}
+		else if (version == 27)
+		{
+			// 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(*this).modify()->incScanVersion();
+		}
+		else if (version == 28)
+		{
+			// Drop Auth mode
+			_session.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.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.execute("DROP TABLE user");
+			_session.execute("ALTER TABLE user_backup RENAME TO user");
+		}
+		else if (version == 29)
+		{
+			_session.execute("ALTER TABLE tracklist_entry ADD date_time TEXT");
+			_session.execute("ALTER TABLE user ADD listenbrainz_token TEXT");
+			_session.execute("ALTER TABLE user ADD scrobbler INTEGER NOT NULL DEFAULT(" + std::to_string(static_cast<int>(User::defaultScrobbler)) + ")");
+			_session.execute("ALTER TABLE track ADD recording_mbid TEXT");
+
+			_session.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(*this).modify()->incScanVersion();
+		}
+		else if (version == 30)
+		{
+			// drop "year" and "original_year" (rescan needed to convert them into dates)
+			_session.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.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.execute("DROP TABLE track");
+			_session.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(*this).modify()->incScanVersion();
+		}
+		else
+		{
+			LMS_LOG(DB, ERROR) << "Database version " << version << " cannot be handled using migration";
+			throw LmsException { LMS_DATABASE_VERSION > version  ? outdatedMsg : "Server binary outdated, please upgrade it to handle this database"};
+		}
+
+		VersionInfo::get(*this).modify()->setVersion(++version);
+	}
+}
+
+Session::Session(Db& db)
+: _db {db}
+{
+	_session.setConnectionPool(_db.getConnectionPool());
+
+	_session.mapClass<VersionInfo>("version_info");
+	_session.mapClass<Artist>("artist");
+	_session.mapClass<AuthToken>("auth_token");
+	_session.mapClass<Cluster>("cluster");
+	_session.mapClass<ClusterType>("cluster_type");
+	_session.mapClass<Release>("release");
+	_session.mapClass<ScanSettings>("scan_settings");
+	_session.mapClass<Track>("track");
+	_session.mapClass<TrackBookmark>("track_bookmark");
+	_session.mapClass<TrackArtistLink>("track_artist_link");
+	_session.mapClass<TrackFeatures>("track_features");
+	_session.mapClass<TrackList>("tracklist");
+	_session.mapClass<TrackListEntry>("tracklist_entry");
+	_session.mapClass<User>("user");
+}
+
+
+enum class OwnedLock
+{
+	None,
+	Shared,
+	Unique,
+};
+
+UniqueTransaction::UniqueTransaction(RecursiveSharedMutex& mutex, Wt::Dbo::Session& session)
+: _lock {mutex},
+ _transaction {session}
+{
+}
+
+SharedTransaction::SharedTransaction(RecursiveSharedMutex& mutex, Wt::Dbo::Session& session)
+: _lock {mutex},
+ _transaction {session}
+{
+}
+
+void
+Session::checkUniqueLocked()
+{
+//	assert(lockDebug[&_db.getMutex()] == OwnedLock::Unique);
+}
+
+void
+Session::checkSharedLocked()
+{
+//	assert(lockDebug[&_db.getMutex()] != OwnedLock::None);
+}
+
+UniqueTransaction
+Session::createUniqueTransaction()
+{
+	return UniqueTransaction {_db.getMutex(), _session};
+}
+
+SharedTransaction
+Session::createSharedTransaction()
+{
+	return SharedTransaction {_db.getMutex(), _session};
+}
+
+void
+Session::prepareTables()
+{
+	// Creation case
+	try {
+	        _session.createTables();
+
+		LMS_LOG(DB, INFO) << "Tables created";
+	}
+	catch (Wt::Dbo::Exception& e)
+	{
+		LMS_LOG(DB, ERROR) << "Cannot create tables: " << e.what();
+	}
+
+	doDatabaseMigrationIfNeeded();
+
+	// Indexes
+	{
+		auto uniqueTransaction {createUniqueTransaction()};
+		_session.execute("CREATE INDEX IF NOT EXISTS artist_name_idx ON artist(name)");
+		_session.execute("CREATE INDEX IF NOT EXISTS artist_sort_name_nocase_idx ON artist(sort_name COLLATE NOCASE)");
+		_session.execute("CREATE INDEX IF NOT EXISTS artist_mbid_idx ON artist(mbid)");
+		_session.execute("CREATE INDEX IF NOT EXISTS auth_token_user_idx ON auth_token(user_id)");
+		_session.execute("CREATE INDEX IF NOT EXISTS auth_token_expiry_idx ON auth_token(expiry)");
+		_session.execute("CREATE INDEX IF NOT EXISTS auth_token_value_idx ON auth_token(value)");
+		_session.execute("CREATE INDEX IF NOT EXISTS cluster_name_idx ON cluster(name)");
+		_session.execute("CREATE INDEX IF NOT EXISTS cluster_cluster_type_idx ON cluster(cluster_type_id)");
+		_session.execute("CREATE INDEX IF NOT EXISTS cluster_type_name_idx ON cluster_type(name)");
+		_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_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)");
+		_session.execute("CREATE INDEX IF NOT EXISTS tracklist_user_idx ON tracklist(user_id)");
+		_session.execute("CREATE INDEX IF NOT EXISTS track_features_track_idx ON track_features(track_id)");
+		_session.execute("CREATE INDEX IF NOT EXISTS track_artist_link_artist_idx ON track_artist_link(artist_id)");
+		_session.execute("CREATE INDEX IF NOT EXISTS track_artist_link_name_idx ON track_artist_link(name)");
+		_session.execute("CREATE INDEX IF NOT EXISTS track_artist_link_track_idx ON track_artist_link(track_id)");
+		_session.execute("CREATE INDEX IF NOT EXISTS track_artist_link_type_idx ON track_artist_link(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)");
+	}
+
+	// Initial settings tables
+	{
+		auto uniqueTransaction {createUniqueTransaction()};
+
+		ScanSettings::init(*this);
+	}
+}
+
+void
+Session::optimize()
+{
+	LMS_LOG(DB, DEBUG) << "Optimizing db...";
+	{
+		auto uniqueTransaction {createUniqueTransaction()};
+		_session.execute("ANALYZE");
+	}
+	LMS_LOG(DB, DEBUG) << "Optimized db!";
+}
+
+} // namespace Database

src/libs/services/database/impl/SqlQuery.cpp

@@ -0,0 +1,199 @@
+/*
+ * Copyright (C) 2013 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 "SqlQuery.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <sstream>
+
+WhereClause&
+WhereClause::And(const WhereClause& otherClause)
+{
+	if (!otherClause._clause.empty()) {
+		if (!_clause.empty())
+			_clause += " AND ";
+		_clause += "(" + otherClause._clause + ")";
+
+		// Add associated bind args
+		for (const std::string& otherBindArg : otherClause._bindArgs)
+		{
+			_bindArgs.push_back(otherBindArg);
+		}
+	}
+	return *this;
+}
+
+WhereClause&
+WhereClause::Or(const WhereClause& otherClause)
+{
+	if (!otherClause._clause.empty()) {
+		if (!_clause.empty())
+			_clause += " OR ";
+		_clause += "(" + otherClause._clause + ")";
+
+		// Add associated bind args
+		for (const std::string& otherBindArg : otherClause._bindArgs)
+		{
+			_bindArgs.push_back(otherBindArg);
+		}
+	}
+	return *this;
+}
+
+std::string
+WhereClause::get(void) const
+{
+	if (!_clause.empty())
+		return "WHERE " + _clause;
+	else
+		return "";
+}
+
+WhereClause&
+WhereClause::bind(const std::string& bindArg)
+{
+	assert(_bindArgs.size() < static_cast<std::size_t>(std::count(_clause.begin(), _clause.end(), '?')));
+
+	_bindArgs.push_back(bindArg);
+
+	return *this;
+}
+
+InnerJoinClause::InnerJoinClause(const std::string& clause)
+:_clause(clause)
+{
+}
+
+InnerJoinClause&
+InnerJoinClause::And(const InnerJoinClause& clause)
+{
+	if (!_clause.empty())
+		_clause += " ";
+
+	_clause += "INNER JOIN " + clause._clause;
+
+	return *this;
+}
+
+SelectStatement::SelectStatement(const std::string& statement)
+{
+	And(statement);
+}
+
+SelectStatement&
+SelectStatement::And(const std::string& statement)
+{
+	_statement.push_back(statement);
+
+	_statement.sort();
+	_statement.unique();
+
+	return *this;
+}
+
+std::string
+SelectStatement::get() const
+{
+	std::string res = "SELECT ";
+
+	for (std::list<std::string>::const_iterator it = _statement.begin(); it != _statement.end(); ++it)
+	{
+		if (it != _statement.begin())
+			res += ",";
+		res += *it;
+	}
+
+	return res;
+}
+
+
+
+GroupByStatement&
+GroupByStatement::And(const GroupByStatement& statement)
+{
+	if( _statement.empty() && !statement._statement.empty())
+		_statement = "GROUP BY ";
+	else if (!_statement.empty() && !statement._statement.empty())
+		_statement += ",";
+
+	_statement += statement._statement;
+	return *this;
+}
+
+FromClause::FromClause(const std::string& clause)
+{
+	_clause.push_back(clause);
+}
+
+FromClause&
+FromClause::And(const FromClause& clause)
+{
+	for (const std::string& fromClause : clause._clause)
+	{
+		_clause.push_back(fromClause);
+	}
+
+	_clause.sort();
+	_clause.unique();
+
+	return *this;
+}
+
+std::string
+FromClause::get() const
+{
+	std::ostringstream oss;
+
+	if (!_clause.empty())
+	{
+		oss << "FROM ";
+		for (std::list<std::string>::const_iterator it = _clause.begin(); it != _clause.end(); ++it) {
+			if (it != _clause.begin())
+				oss << ",";
+
+			oss << *it;
+		}
+	}
+
+	return oss.str();
+}
+
+std::string
+SqlQuery::get(void) const
+{
+	std::ostringstream oss;
+
+	oss << _selectStatement.get();
+
+	if (!_fromClause.get().empty())
+		oss << " " << _fromClause.get();
+
+	if (!_innerJoinClause.get().empty())
+		oss << " " << _innerJoinClause.get();
+
+	if (!_whereClause.get().empty())
+		oss << " " << _whereClause.get();
+
+	if (!_groupByStatement.get().empty())
+		oss << " " << _groupByStatement.get();
+
+	return oss.str();
+}
+

src/libs/services/database/impl/SqlQuery.hpp

@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2013 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 <list>
+#include <string>
+
+
+class WhereClause
+{
+	public:
+
+		WhereClause() {}
+		WhereClause(const std::string& clause) { _clause = clause; }
+
+		WhereClause& And(const WhereClause& clause);
+		WhereClause& Or(const WhereClause& clause);
+
+		// Arguments binding (for each '?' in where clause)
+		WhereClause& bind(const std::string& arg);
+
+		std::string get() const;
+		const std::list<std::string>&	getBindArgs(void) const	{return _bindArgs;}
+
+	private:
+
+		std::string _clause;		// WHERE clause
+		std::list<std::string>  _bindArgs;
+
+};
+
+class InnerJoinClause
+{
+	public:
+
+		InnerJoinClause() {}
+		InnerJoinClause(const std::string& clause);
+
+		InnerJoinClause&	And(const InnerJoinClause& clause);
+		std::string get() const	{ return _clause;}
+
+	private:
+
+		std::string _clause;
+};
+
+class GroupByStatement
+{
+	public:
+		GroupByStatement() {}
+		GroupByStatement(const std::string& statement) { _statement = statement; }
+
+		GroupByStatement& And(const GroupByStatement& statement);
+
+		std::string get() const      {return _statement;}
+
+	private:
+		std::string _statement;		// SELECT statement
+
+};
+
+class SelectStatement
+{
+	public:
+		SelectStatement() {};
+		SelectStatement(const std::string& item);
+
+		SelectStatement& And(const std::string& item);
+
+		std::string get() const;
+
+	private:
+
+		std::list<std::string>	_statement;
+};
+
+class FromClause
+{
+	public:
+
+		FromClause() {}
+		FromClause(const std::string& clause);
+
+		FromClause& And(const FromClause& clause);
+
+		std::string get() const;
+
+	private:
+
+		std::list<std::string>	_clause;
+
+};
+
+class SqlQuery
+{
+	public:
+
+		SelectStatement&	select(void)		{ return _selectStatement;}
+		SelectStatement&	select(const std::string& statement)		{ _selectStatement = SelectStatement(statement); return _selectStatement; }
+		FromClause&		from(void)		{ return _fromClause; }
+		FromClause&		from(const std::string& clause)			{ _whereClause = WhereClause(clause); return _fromClause; }
+		InnerJoinClause&	innerJoin(void)		{ return _innerJoinClause; }
+		WhereClause&		where(void)		{ return _whereClause; }
+		const WhereClause&	where(void) const	{ return _whereClause; }
+		GroupByStatement&	groupBy(void) 		{ return _groupByStatement; }
+		const GroupByStatement&	groupBy(void) const	{ return _groupByStatement; }
+
+		std::string get(void) const;
+
+	private:
+
+		SelectStatement		_selectStatement;	// SELECT statement
+		InnerJoinClause		_innerJoinClause;	// INNER JOIN
+		FromClause		_fromClause;		// FROM tables
+		WhereClause		_whereClause;		// WHERE clause
+		GroupByStatement	_groupByStatement;	// GROUP BY statement
+};
+

src/libs/services/database/impl/StringViewTraits.hpp

@@ -0,0 +1,33 @@
+/*
+ * 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
+
+namespace Wt::Dbo
+{
+	template<>
+	struct sql_value_traits<std::string_view>
+	{
+		static void bind(std::string_view str, SqlStatement *statement, int column, int /* size */)
+		{
+			statement->bind(column, std::string {str});
+		}
+	};
+}
+

src/libs/services/database/impl/Track.cpp

@@ -0,0 +1,645 @@
+/*
+ * Copyright (C) 2013-2016 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 "database/Track.hpp"
+
+#include <Wt/Dbo/WtSqlTraits.h>
+
+#include "database/Artist.hpp"
+#include "database/Cluster.hpp"
+#include "database/Release.hpp"
+#include "database/TrackArtistLink.hpp"
+#include "database/TrackFeatures.hpp"
+#include "database/Session.hpp"
+#include "database/User.hpp"
+#include "utils/Logger.hpp"
+
+#include "SqlQuery.hpp"
+#include "StringViewTraits.hpp"
+#include "Traits.hpp"
+#include "Utils.hpp"
+
+namespace Database {
+
+template <typename T>
+static
+Wt::Dbo::Query<T>
+createQuery(Session& session,
+		const std::string& queryStr,
+		const std::vector<ClusterId>& clusterIds,
+		const std::vector<std::string_view>& keywords)
+{
+	session.checkSharedLocked();
+
+	auto query {session.getDboSession().query<T>(queryStr)};
+
+	for (std::string_view keyword : keywords)
+		query.where("t.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'").bind("%" + escapeLikeKeyword(keyword) + "%");
+
+	if (!clusterIds.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 : clusterIds)
+		{
+			clusterClause.Or(WhereClause("c.id = ?"));
+			query.bind(clusterId);
+		}
+
+		oss << " " << clusterClause.get();
+		oss << " GROUP BY t.id HAVING COUNT(*) = " << clusterIds.size() << ")";
+
+		query.where(oss.str());
+	}
+
+	return query;
+}
+
+Track::Track(const std::filesystem::path& p)
+: _filePath {p.string()}
+{
+}
+
+std::size_t
+Track::getCount(Session& session)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().query<int>("SELECT COUNT(*) FROM track");
+}
+
+std::vector<Track::pointer>
+Track::getAll(Session& session, std::optional<std::size_t> limit)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().find<Track>()
+		.limit(limit ? static_cast<int>(*limit) : -1)
+		.resultList()};
+
+	return std::vector<Track::pointer>(std::cbegin(res), std::cend(res));
+}
+
+std::vector<Track::pointer>
+Track::getAllRandom(Session& session, const std::vector<ClusterId>& clusterIds, std::optional<std::size_t> limit)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<Wt::Dbo::ptr<Track>>(session, "SELECT t from track t", clusterIds, {})};
+	auto collection {query
+		.orderBy("RANDOM()")
+		.limit(limit ? static_cast<int>(*limit) + 1: -1)
+		.resultList()};
+
+	return std::vector<pointer>(collection.begin(), collection.end());
+}
+
+std::vector<TrackId>
+Track::getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusterIds, std::optional<std::size_t> limit)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<TrackId>(session, "SELECT t.id from track t", clusterIds, {})};
+
+	Wt::Dbo::collection<TrackId> collection = query
+		.orderBy("RANDOM()")
+		.limit(limit ? static_cast<int>(*limit) + 1: -1);
+
+	return std::vector<TrackId>(collection.begin(), collection.end());
+}
+
+
+std::vector<TrackId>
+Track::getAllIds(Session& session)
+{
+	session.checkSharedLocked();
+
+	Wt::Dbo::collection<TrackId> res = session.getDboSession().query<TrackId>("SELECT id FROM track");
+	return std::vector<TrackId>(res.begin(), res.end());
+}
+
+Track::pointer
+Track::getByPath(Session& session, const std::filesystem::path& p)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().find<Track>().where("file_path = ?").bind(p.string()).resultValue();
+}
+
+Track::pointer
+Track::getById(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::getByRecordingMBID(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());
+}
+
+Track::pointer
+Track::create(Session& session, const std::filesystem::path& p)
+{
+	session.checkUniqueLocked();
+
+	Track::pointer res {session.getDboSession().add(std::make_unique<Track>(p))};
+	session.getDboSession().flush();
+
+	return res;
+}
+
+std::vector<std::pair<TrackId, std::filesystem::path>>
+Track::getAllPaths(Session& session, std::optional<std::size_t> offset, std::optional<std::size_t> size)
+{
+	using QueryResultType = std::tuple<TrackId, std::string>;
+	session.checkSharedLocked();
+
+	Wt::Dbo::collection<QueryResultType> queryRes = session.getDboSession().query<QueryResultType>("SELECT id,file_path FROM track")
+		.limit(size ? static_cast<int>(*size) + 1 : -1)
+		.offset(offset ? static_cast<int>(*offset) : -1);
+
+	std::vector<std::pair<TrackId, std::filesystem::path>> result;
+	result.reserve(queryRes.size());
+
+	std::transform(std::begin(queryRes), std::end(queryRes), std::back_inserter(result),
+			[](const QueryResultType& queryResult)
+			{
+				return std::make_pair(std::get<0>(queryResult), std::get<1>(queryResult));
+			});
+
+	return result;
+}
+
+std::vector<Track::pointer>
+Track::getMBIDDuplicates(Session& session)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Track>>( "SELECT track 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")
+		.resultList()};
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<Track::pointer>
+Track::getLastWritten(Session& session, std::optional<Wt::WDateTime> after, const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<Wt::Dbo::ptr<Track>>(session, "SELECT t from track t", clusterIds, {})};
+	if (after)
+		query.where("t.file_last_write > ?").bind(after);
+
+	auto collection {query
+		.orderBy("t.file_last_write DESC")
+		.groupBy("t.id")
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.limit(range ? static_cast<int>(range->limit) + 1: -1)
+		.resultList()};
+
+	std::vector<pointer> res(collection.begin(), collection.end());
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+std::vector<Track::pointer>
+Track::getAllWithRecordingMBIDAndMissingFeatures(Session& session)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Track>>
+		("SELECT t 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)")
+		.resultList()};
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<TrackId>
+Track::getAllIdsWithFeatures(Session& session, std::optional<std::size_t> limit)
+{
+	session.checkSharedLocked();
+
+	Wt::Dbo::collection<TrackId> res = session.getDboSession().query<TrackId>
+		("SELECT t.id FROM track t")
+		.where("EXISTS (SELECT * from track_features t_f WHERE t_f.track_id = t.id)")
+		.limit(limit ? static_cast<int>(*limit) : -1);
+
+	return std::vector<TrackId>(res.begin(), res.end());
+}
+
+std::vector<TrackId>
+Track::getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit)
+{
+	session.checkSharedLocked();
+
+	Wt::Dbo::collection<TrackId> res = session.getDboSession().query<TrackId>
+		("SELECT DISTINCT t.id FROM track t"
+		 	" INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
+		.limit(limit ? static_cast<int>(*limit) : -1);
+
+	return std::vector<TrackId>(res.begin(), res.end());
+}
+
+std::vector<Track::pointer>
+Track::getStarred(Session& session,
+		ObjectPtr<User> user,
+		const std::vector<ClusterId>& clusterIds,
+		std::optional<Range> range, bool& moreResults)
+{
+	session.checkSharedLocked();
+
+	auto query {createQuery<Wt::Dbo::ptr<Track>>(session, "SELECT t from track t", clusterIds, {})};
+	{
+		std::ostringstream oss;
+		oss << "t.id IN (SELECT DISTINCT t.id FROM track t"
+			" INNER JOIN user_track_starred uts ON uts.track_id = t.id"
+			" INNER JOIN user u ON u.id = uts.user_id WHERE u.id = ?)";
+
+		query.bind(user->getId().toString());
+		query.where(oss.str());
+	}
+
+	auto collection {query
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.limit(range ? static_cast<int>(range->limit) + 1: -1)
+		.resultList()};
+
+	std::vector<pointer> res(collection.begin(), collection.end());
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+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());
+}
+
+bool
+Track::hasTrackFeatures() const
+{
+	return (_trackFeatures.lock() != Wt::Dbo::ptr<Database::TrackFeatures> {});
+}
+
+std::vector<Track::pointer>
+Track::getByFilter(Session& session,
+		const std::vector<ClusterId>& clusterIds,
+		const std::vector<std::string_view>& keywords,
+		std::optional<Range> range,
+		bool& moreResults)
+{
+	session.checkSharedLocked();
+
+	auto collection {createQuery<Wt::Dbo::ptr<Track>>(session, "SELECT t from track t", clusterIds, keywords)
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
+
+	std::vector<pointer> res(collection.begin(), collection.end());
+	if (range && (res.size() == static_cast<std::size_t>(range->limit) + 1))
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+std::vector<Track::pointer>
+Track::getByNameAndReleaseName(Session& session, std::string_view trackName, std::string_view releaseName)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Track>>("SELECT t from track t")
+		.join("release r ON t.release_id = r.id")
+		.where("t.name = ?").bind(trackName)
+		.where("r.name = ?").bind(releaseName)
+		.resultList()};
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<Track::pointer>
+Track::getSimilarTracks(Session& session,
+				const std::vector<TrackId>& tracks,
+				std::optional<std::size_t> offset,
+				std::optional<std::size_t> size)
+{
+	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<Wt::Dbo::ptr<Track>>(
+			"SELECT t 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()")
+		.limit(size ? static_cast<int>(*size) : -1)
+		.offset(offset ? static_cast<int>(*offset) : -1)};
+
+	for (TrackId trackId : tracks)
+		query.bind(trackId);
+
+	for (TrackId trackId : tracks)
+		query.bind(trackId);
+
+	auto res {query.resultList()};
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<Track::pointer>
+Track::getByClusters(Session& session, const std::vector<ClusterId>& clusters)
+{
+	assert(!clusters.empty());
+	session.checkSharedLocked();
+
+	bool moreResults;
+	return getByFilter(session,
+			clusters,
+			{}, // keywords
+			std::nullopt, // range
+			moreResults);
+}
+
+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));
+}
+
+void
+Track::setFeatures(const ObjectPtr<TrackFeatures>& features)
+{
+	_trackFeatures = getDboPtr(features);
+}
+
+std::optional<std::size_t>
+Track::getTrackNumber() const
+{
+	return (_trackNumber > 0) ? std::make_optional<std::size_t>(_trackNumber) : std::nullopt;
+}
+
+std::optional<std::size_t>
+Track::getTotalTrack() const
+{
+	return (_totalTrack > 0) ? std::make_optional<std::size_t>(_totalTrack) : std::nullopt;
+}
+
+std::optional<std::size_t>
+Track::getDiscNumber() const
+{
+	return (_discNumber > 0) ? std::make_optional<std::size_t>(_discNumber) : std::nullopt;
+}
+
+std::optional<std::size_t>
+Track::getTotalDisc() const
+{
+	return (_totalDisc > 0) ? std::make_optional<std::size_t>(_totalDisc) : std::nullopt;
+}
+
+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 (TrackArtistLinkType type : linkTypes)
+		{
+			(void) type;
+			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 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 (TrackArtistLinkType type : linkTypes)
+		{
+			(void) type;
+			if (!first)
+				oss << ", ";
+			oss << "?";
+			first = false;
+		}
+		oss << ")";
+	}
+
+	Wt::Dbo::Query<ArtistId> query {session()->query<ArtistId>(oss.str())
+		.where("t.id = ?").bind(getId())};
+
+	for (TrackArtistLinkType type : linkTypes)
+		query.bind(type);
+
+	Wt::Dbo::collection<ArtistId> res = query;
+	return std::vector<ArtistId>(std::begin(res), std::end(res));
+}
+
+std::vector<TrackArtistLink::pointer>
+Track::getArtistLinks() const
+{
+	return std::vector<TrackArtistLink::pointer>(_trackArtistLinks.begin(), _trackArtistLinks.end());
+}
+
+ObjectPtr<TrackFeatures>
+Track::getTrackFeatures() const
+{
+	return _trackFeatures.lock();
+}
+
+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 Database
+

src/libs/services/database/impl/TrackArtistLink.cpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2013-2016 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 "database/TrackArtistLink.hpp"
+
+#include "database/Artist.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+
+#include "Traits.hpp"
+
+namespace Database {
+
+TrackArtistLink::TrackArtistLink(ObjectPtr<Track> track, ObjectPtr<Artist> artist, TrackArtistLinkType type)
+: _type {type},
+_track {getDboPtr(track)},
+_artist {getDboPtr(artist)}
+{
+}
+
+TrackArtistLink::pointer
+TrackArtistLink::create(Session& session, ObjectPtr<Track> track, ObjectPtr<Artist> artist, TrackArtistLinkType type)
+{
+	session.checkUniqueLocked();
+
+	TrackArtistLink::pointer res {session.getDboSession().add(std::make_unique<TrackArtistLink>(track, artist, type))};
+	session.getDboSession().flush();
+
+	return res;
+}
+
+EnumSet<TrackArtistLinkType>
+TrackArtistLink::getUsedTypes(Session& session)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().query<TrackArtistLinkType>("SELECT DISTINCT type from track_artist_link").resultList()};
+
+	return EnumSet<TrackArtistLinkType>(std::begin(res), std::end(res));
+}
+
+}
+

src/libs/services/database/impl/TrackBookmark.cpp

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2020 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 "database/TrackBookmark.hpp"
+
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "database/User.hpp"
+#include "Traits.hpp"
+
+namespace Database {
+
+TrackBookmark::TrackBookmark(ObjectPtr<User> user, ObjectPtr<Track> track)
+: _user {getDboPtr(user)},
+_track {getDboPtr(track)}
+{
+}
+
+TrackBookmark::pointer
+TrackBookmark::create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track)
+{
+	session.checkUniqueLocked();
+
+	TrackBookmark::pointer res {session.getDboSession().add(std::make_unique<TrackBookmark>(user, track))};
+	session.getDboSession().flush();
+
+	return res;
+}
+
+std::vector<TrackBookmark::pointer>
+TrackBookmark::getAll(Session& session)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().find<TrackBookmark>().resultList()};
+	return std::vector<TrackBookmark::pointer>(std::cbegin(res), std::cend(res));
+}
+
+std::vector<TrackBookmark::pointer>
+TrackBookmark::getByUser(Session& session, User::pointer user)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().find<TrackBookmark>()
+				.where("user_id = ?").bind(user->getId())
+				.resultList()};
+
+	return std::vector<TrackBookmark::pointer>(std::cbegin(res), std::cend(res));
+}
+
+TrackBookmark::pointer
+TrackBookmark::getByUser(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().find<TrackBookmark>()
+		.where("user_id = ?").bind(user->getId())
+		.where("track_id = ?").bind(track->getId())
+		.resultValue();
+}
+
+TrackBookmark::pointer
+TrackBookmark::getById(Session& session, TrackBookmarkId id)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().find<TrackBookmark>()
+		.where("id = ?").bind(id)
+		.resultValue();
+}
+
+
+} // namespace Database
+

src/libs/services/database/impl/TrackFeatures.cpp

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2018 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 "database/TrackFeatures.hpp"
+
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/json_parser.hpp>
+
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "utils/Logger.hpp"
+
+namespace Database {
+
+TrackFeatures::TrackFeatures(ObjectPtr<Track> track, const std::string& jsonEncodedFeatures)
+: _data {jsonEncodedFeatures},
+_track {getDboPtr(track)}
+{
+}
+
+TrackFeatures::pointer
+TrackFeatures::create(Session& session, ObjectPtr<Track> track, const std::string& jsonEncodedFeatures)
+{
+	session.checkUniqueLocked();
+	return session.getDboSession().add(std::make_unique<TrackFeatures>(track, jsonEncodedFeatures));
+}
+
+FeatureValues
+TrackFeatures::getFeatureValues(const FeatureName& featureNode) const
+{
+	FeatureValuesMap featuresValuesMap {getFeatureValuesMap({featureNode})};
+	return std::move(featuresValuesMap[featureNode]);
+}
+
+FeatureValuesMap
+TrackFeatures::getFeatureValuesMap(const std::unordered_set<FeatureName>& featureNames) const
+{
+	try
+	{
+		std::istringstream iss {_data};
+		boost::property_tree::ptree root;
+
+		boost::property_tree::read_json(iss, root);
+
+		FeatureValuesMap res;
+		for (const FeatureName& featureName : featureNames)
+		{
+			FeatureValues& featureValues {res[featureName]};
+
+			auto node {root.get_child(featureName)};
+
+			bool hasChildren = false;
+			for (const auto& child : node.get_child(""))
+			{
+				hasChildren = true;
+				featureValues.push_back(child.second.get_value<double>());
+			}
+
+			if (!hasChildren)
+				featureValues.push_back(node.get_value<double>());
+		}
+
+		return res;
+	}
+	catch (boost::property_tree::ptree_error& error)
+	{
+		LMS_LOG(DB, ERROR) << "Track " << _track.id() << ": ptree exception: " << error.what();
+		return {};
+	}
+}
+
+} // namespace Database

src/libs/services/database/impl/TrackList.cpp

@@ -0,0 +1,523 @@
+/*
+ * Copyright (C) 2014 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 "database/TrackList.hpp"
+
+#include <cassert>
+
+#include "utils/Logger.hpp"
+
+#include "database/Artist.hpp"
+#include "database/Cluster.hpp"
+#include "database/Release.hpp"
+#include "database/Session.hpp"
+#include "database/User.hpp"
+#include "database/Track.hpp"
+#include "SqlQuery.hpp"
+#include "StringViewTraits.hpp"
+#include "Traits.hpp"
+
+namespace Database {
+
+TrackList::TrackList(std::string_view name, Type type, bool isPublic, ObjectPtr<User> user)
+: _name {name},
+ _type {type},
+ _isPublic {isPublic},
+ _user {getDboPtr(user)}
+{
+
+}
+
+TrackList::pointer
+TrackList::create(Session& session, std::string_view name, Type type, bool isPublic, ObjectPtr<User> user)
+{
+	session.checkUniqueLocked();
+	assert(user);
+
+	TrackList::pointer res {session.getDboSession().add( std::make_unique<TrackList>(name, type, isPublic, user) )};
+	session.getDboSession().flush();
+
+	return res;
+}
+
+TrackList::pointer
+TrackList::get(Session& session, std::string_view name, Type type, ObjectPtr<User> user)
+{
+	session.checkSharedLocked();
+	assert(user);
+
+	return session.getDboSession().find<TrackList>()
+		.where("name = ?").bind(name)
+		.where("type = ?").bind(type)
+		.where("user_id = ?").bind(user->getId()).resultValue();
+}
+
+std::vector<TrackList::pointer>
+TrackList::getAll(Session& session)
+{
+	session.checkSharedLocked();
+
+	auto res = session.getDboSession().find<TrackList>().resultList();
+	return std::vector<TrackList::pointer>(res.begin(), res.end());
+}
+
+std::vector<TrackList::pointer>
+TrackList::getAll(Session& session, ObjectPtr<User> user)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().find<TrackList>()
+		.where("user_id = ?").bind(user->getId())
+		.orderBy("name COLLATE NOCASE")
+		.resultList()};
+
+	return std::vector<TrackList::pointer>(res.begin(), res.end());
+}
+
+std::vector<TrackList::pointer>
+TrackList::getAll(Session& session, ObjectPtr<User> user, Type type)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().find<TrackList>()
+		.where("user_id = ?").bind(user->getId())
+		.where("type = ?").bind(type)
+		.orderBy("name COLLATE NOCASE")
+		.resultList()};
+
+	return std::vector<TrackList::pointer>(res.begin(), res.end());
+}
+
+TrackList::pointer
+TrackList::getById(Session& session, TrackListId id)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().find<TrackList>().where("id = ?").bind(id).resultValue();
+}
+
+bool
+TrackList::isEmpty() const
+{
+	return _entries.empty();
+}
+
+std::size_t
+TrackList::getCount() const
+{
+	return _entries.size();
+}
+
+TrackListEntry::pointer
+TrackList::getEntry(std::size_t pos) const
+{
+	TrackListEntry::pointer res;
+
+	auto entries = getEntries(pos, 1);
+	if (!entries.empty())
+		res = entries.front();
+
+	return res;
+}
+
+std::vector<TrackListEntry::pointer>
+TrackList::getEntries(std::optional<std::size_t> offset, std::optional<std::size_t> size) const
+{
+	assert(session());
+
+	auto entries {
+		session()->find<TrackListEntry>()
+		.where("tracklist_id = ?").bind(getId())
+		.orderBy("id")
+		.limit(size ? static_cast<int>(*size) : -1)
+		.offset(offset ? static_cast<int>(*offset) : -1)
+		.resultList()};
+
+	return std::vector<TrackListEntry::pointer>(entries.begin(), entries.end());
+}
+
+TrackListEntry::pointer
+TrackList::getEntryByTrackAndDateTime(ObjectPtr<Track> track, const Wt::WDateTime& dateTime) const
+{
+	assert(session());
+
+	return session()->find<TrackListEntry>()
+			.where("tracklist_id = ?").bind(getId())
+			.where("track_id = ?").bind(track->getId())
+			.where("date_time = ?").bind(Wt::WDateTime::fromTime_t(dateTime.toTime_t()))
+			.resultValue();
+}
+
+static
+Wt::Dbo::Query<Wt::Dbo::ptr<Artist>>
+createArtistsQuery(Wt::Dbo::Session& session, const std::string& queryStr, TrackListId tracklistId, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType)
+{
+	auto query {session.query<Wt::Dbo::ptr<Artist>>(queryStr)};
+	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.join("tracklist_entry p_e ON p_e.track_id = t.id");
+	query.join("tracklist p ON p.id = p_e.tracklist_id");
+
+	query.where("p.id = ?").bind(tracklistId);
+
+	if (linkType)
+		query.where("t_a_l.type = ?").bind(*linkType);
+
+	if (!clusterIds.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";
+
+		WhereClause clusterClause;
+		for (auto id : clusterIds)
+		{
+			clusterClause.Or(WhereClause("c.id = ?"));
+			query.bind(id);
+		}
+
+		oss << " " << clusterClause.get();
+		oss << " GROUP BY t.id,a.id HAVING COUNT(DISTINCT c.id) = " << clusterIds.size() << ")";
+
+		query.where(oss.str());
+	}
+
+	return query;
+}
+
+static
+Wt::Dbo::Query<Wt::Dbo::ptr<Release>>
+createReleasesQuery(Wt::Dbo::Session& session, const std::string& queryStr, TrackListId tracklistId, const std::vector<ClusterId>& clusterIds)
+{
+	auto query {session.query<Wt::Dbo::ptr<Release>>(queryStr)};
+	query.join("track t ON t.release_id = r.id");
+	query.join("tracklist_entry p_e ON p_e.track_id = t.id");
+	query.join("tracklist p ON p.id = p_e.tracklist_id");
+
+	query.where("p.id = ?").bind(tracklistId);
+
+	if (!clusterIds.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";
+
+		WhereClause clusterClause;
+		for (ClusterId id : clusterIds)
+		{
+			clusterClause.Or(WhereClause("c.id = ?"));
+			query.bind(id);
+		}
+
+		oss << " " << clusterClause.get();
+		oss << " GROUP BY t.id HAVING COUNT(DISTINCT c.id) = " << clusterIds.size() << ")";
+
+		query.where(oss.str());
+	}
+
+	return query;
+}
+
+static
+Wt::Dbo::Query<Wt::Dbo::ptr<Track>>
+createTracksQuery(Wt::Dbo::Session& session, TrackListId tracklistId, const std::vector<ClusterId>& clusterIds)
+{
+	auto query {session.query<Wt::Dbo::ptr<Track>>("SELECT t from track t INNER JOIN tracklist_entry p_e ON p_e.track_id = t.id INNER JOIN tracklist p ON p.id = p_e.tracklist_id")};
+
+	query.where("p.id = ?").bind(tracklistId);
+
+	if (!clusterIds.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 (auto id : clusterIds)
+		{
+			clusterClause.Or(WhereClause("c.id = ?")).bind(id.toString());
+			query.bind(id);
+		}
+
+		oss << " " << clusterClause.get();
+		oss << " GROUP BY t.id HAVING COUNT(*) = " << clusterIds.size() << ")";
+
+		query.where(oss.str());
+	}
+
+	return query;
+}
+
+std::vector<Artist::pointer>
+TrackList::getArtistsReverse(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const
+{
+	assert(session());
+
+	auto collection {createArtistsQuery(*session(), "SELECT a from artist a", getId(), clusterIds, linkType)
+		.groupBy("a.id").having("p_e.date_time = MAX(p_e.date_time)")
+		.orderBy("p_e.date_time DESC")
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
+
+	auto res {std::vector<Artist::pointer>(collection.begin(), collection.end())};
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+std::vector<Release::pointer>
+TrackList::getReleasesReverse(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
+{
+	assert(session());
+
+	auto collection {createReleasesQuery(*session(), "SELECT r from release r", getId(), clusterIds)
+		.groupBy("r.id").having("p_e.date_time = MAX(p_e.date_time)")
+		.orderBy("p_e.date_time DESC")
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
+
+	std::vector<Release::pointer> res(collection.begin(), collection.end());
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+std::vector<Track::pointer>
+TrackList::getTracksReverse(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
+{
+	assert(session());
+
+	auto collection {createTracksQuery(*session(), getId(), clusterIds)
+		.groupBy("t.id").having("p_e.date_time = MAX(p_e.date_time)")
+		.orderBy("p_e.date_time DESC")
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
+
+	std::vector<Track::pointer> res(collection.begin(), collection.end());
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+std::vector<Cluster::pointer>
+TrackList::getClusters() const
+{
+	assert(session());
+
+	auto res {session()->query<Wt::Dbo::ptr<Cluster>>("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 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 = ?").bind(getId())
+		.groupBy("c.id")
+		.orderBy("COUNT(c.id) DESC")
+		.resultList()};
+
+	return std::vector<Cluster::pointer>(res.begin(), res.end());
+}
+
+bool
+TrackList::hasTrack(TrackId trackId) const
+{
+	assert(session());
+
+	Wt::Dbo::collection<TrackListEntry::pointer> res = session()->query<TrackListEntry::pointer>("SELECT p_e from tracklist_entry p_e INNER JOIN tracklist p ON p_e.tracklist_id = p.id")
+		.where("p_e.track_id = ?").bind(trackId)
+		.where("p.id = ?").bind(getId());
+
+	return res.size() > 0;
+}
+
+std::vector<Track::pointer>
+TrackList::getSimilarTracks(std::optional<std::size_t> offset, std::optional<std::size_t> size) const
+{
+	assert(session());
+
+	auto res {session()->query<Wt::Dbo::ptr<Track>>(
+			"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 = ?)"
+					" 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())
+		.bind(getId())
+		.groupBy("t.id")
+		.orderBy("COUNT(*) DESC, RANDOM()")
+		.limit(size ? static_cast<int>(*size) : -1)
+		.offset(offset ? static_cast<int>(*offset) : -1)
+		.resultList()};
+
+	return std::vector<Track::pointer>(res.begin(), res.end());
+}
+
+std::vector<TrackId>
+TrackList::getTrackIds() const
+{
+	assert(session());
+
+	Wt::Dbo::collection<TrackId> res = session()->query<TrackId>("SELECT p_e.track_id from tracklist_entry p_e INNER JOIN tracklist p ON p_e.tracklist_id = p.id")
+		.where("p.id = ?").bind(getId());
+
+	return std::vector<TrackId>(res.begin(), res.end());
+}
+
+std::chrono::milliseconds
+TrackList::getDuration() const
+{
+	assert(session());
+
+	using milli = std::chrono::duration<int, std::milli>;
+
+	Wt::Dbo::Query<milli> query {session()->query<milli>("SELECT COALESCE(SUM(duration), 0) FROM track t INNER JOIN tracklist_entry p_e ON t.id = p_e.track_id")
+			.where("p_e.tracklist_id = ?").bind(getId())};
+
+	return query.resultValue();
+}
+
+std::vector<Artist::pointer>
+TrackList::getTopArtists(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const
+{
+	assert(session());
+
+	auto query {createArtistsQuery(*session(), "SELECT a from artist a", getId(), clusterIds, linkType)};
+
+	auto collection {query
+		.orderBy("COUNT(a.id) DESC")
+		.groupBy("a.id")
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
+
+	std::vector<Artist::pointer> res(collection.begin(), collection.end());
+
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+std::vector<Release::pointer>
+TrackList::getTopReleases(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
+{
+	assert(session());
+
+	auto query {createReleasesQuery(*session(), "SELECT r from release r", getId(), clusterIds)};
+	auto collection {query
+		.orderBy("COUNT(r.id) DESC")
+		.groupBy("r.id")
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
+
+	std::vector<Release::pointer> res(collection.begin(), collection.end());
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+std::vector<Track::pointer>
+TrackList::getTopTracks(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
+{
+	assert(session());
+
+	auto query {createTracksQuery(*session(), getId(), clusterIds)};
+	auto collection {query
+		.orderBy("COUNT(t.id) DESC")
+		.groupBy("t.id")
+		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
+
+	std::vector<Track::pointer> res(collection.begin(), collection.end());
+	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
+	{
+		moreResults = true;
+		res.pop_back();
+	}
+	else
+		moreResults = false;
+
+	return res;
+}
+
+TrackListEntry::TrackListEntry(ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist, const Wt::WDateTime& dateTime)
+: _dateTime {Wt::WDateTime::fromTime_t(dateTime.toTime_t())} // force second resolution
+, _track {getDboPtr(track)}
+, _tracklist {getDboPtr(tracklist)}
+{
+	assert(_dateTime.isValid());
+}
+
+TrackListEntry::pointer
+TrackListEntry::create(Session& session, ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist, const Wt::WDateTime& dateTime)
+{
+	session.checkUniqueLocked();
+	assert(track);
+	assert(tracklist);
+
+	auto res = session.getDboSession().add(std::make_unique<TrackListEntry>( track, tracklist, dateTime));
+	session.getDboSession().flush();
+
+	return res;
+}
+
+TrackListEntry::pointer
+TrackListEntry::getById(Session& session, TrackListEntryId id)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().find<TrackListEntry>().where("id = ?").bind(id).resultValue();
+}
+
+} // namespace Database

src/libs/services/database/impl/Traits.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 <type_traits>
+#include <Wt/Dbo/StdSqlTraits.h>
+
+#include "database/Types.hpp"
+
+namespace Wt::Dbo
+{
+
+	template<typename T>
+	struct sql_value_traits<T, typename std::enable_if<std::is_base_of<Database::IdType, T>::value>::type>
+	{
+		static_assert(!std::is_same_v<Database::IdType, T>, "Cannot use IdType, use derived types");
+		static const bool specialized = true;
+
+		static std::string type(SqlConnection *conn, int size)
+		{
+			return sql_value_traits<typename T::ValueType, void>::type(conn, size);
+		}
+
+		static void bind(const T& v, SqlStatement *statement, int column, int size)
+		{
+			sql_value_traits<typename T::ValueType>::bind(v.getValue(), statement, column, size);
+		}
+
+		static bool read(T& v, SqlStatement *statement, int column, int size)
+		{
+			typename T::ValueType value;
+			if (sql_value_traits<typename T::ValueType>::read(value, statement, column, size))
+			{
+				v = value;
+				return true;
+			}
+
+			v = {};
+			return false;
+		}
+	};
+}
+

src/libs/services/database/impl/User.cpp

@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2013 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 "database/User.hpp"
+
+#include "database/Artist.hpp"
+#include "database/Release.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "database/TrackList.hpp"
+#include "utils/Logger.hpp"
+#include "StringViewTraits.hpp"
+#include "Traits.hpp"
+
+namespace Database {
+
+
+AuthToken::AuthToken(const std::string& value, const Wt::WDateTime& expiry, ObjectPtr<User> user)
+: _value {value}
+, _expiry {expiry}
+, _user {getDboPtr(user)}
+{
+
+}
+
+AuthToken::pointer
+AuthToken::create(Session& session, const std::string& value, const Wt::WDateTime& expiry, ObjectPtr<User> user)
+{
+	session.checkUniqueLocked();
+
+	AuthToken::pointer res {session.getDboSession().add(std::make_unique<AuthToken>(value, expiry, user))};
+	session.getDboSession().flush();
+
+	return res;
+}
+
+void
+AuthToken::removeExpiredTokens(Session& session, const Wt::WDateTime& now)
+{
+	session.checkUniqueLocked();
+
+	session.getDboSession().execute
+		("DELETE FROM auth_token WHERE expiry < ?").bind(now);
+}
+
+AuthToken::pointer
+AuthToken::getByValue(Session& session, const std::string& value)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().find<AuthToken>()
+		.where("value = ?").bind(value)
+		.resultValue();
+}
+
+static const std::string queuedListName {"__queued_tracks__"};
+
+User::User(std::string_view loginName)
+: _loginName {loginName}
+{
+}
+
+std::vector<User::pointer>
+User::getAll(Session& session)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().find<User>().resultList()};
+	return std::vector<pointer>(res.begin(), res.end());
+}
+
+std::vector<UserId>
+User::getAllIds(Session& session)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().query<UserId>("SELECT id FROM user").resultList()};
+	return std::vector<UserId>(res.begin(), res.end());
+}
+
+User::pointer
+User::getDemo(Session& session)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().find<User>().where("type = ?").bind(UserType::DEMO).resultValue();
+}
+
+std::size_t
+User::getCount(Session& session)
+{
+	session.checkSharedLocked();
+
+	return session.getDboSession().query<int>("SELECT COUNT(*) FROM user");
+}
+
+User::pointer
+User::create(Session& session, std::string_view loginName)
+{
+	session.checkUniqueLocked();
+
+	User::pointer user {session.getDboSession().add(std::make_unique<User>(loginName))};
+
+	TrackList::create(session, queuedListName, TrackList::Type::Internal, false, user);
+
+	session.getDboSession().flush();
+
+	return user;
+}
+
+User::pointer
+User::getById(Session& session, UserId id)
+{
+	return session.getDboSession().find<User>().where("id = ?").bind(id).resultValue();
+}
+
+User::pointer
+User::getByLoginName(Session& session, std::string_view name)
+{
+	return session.getDboSession().find<User>()
+		.where("login_name = ?").bind(name)
+		.resultValue();
+}
+
+void
+User::setSubsonicTranscodeBitrate(Bitrate bitrate)
+{
+	assert(audioTranscodeAllowedBitrates.find(bitrate) != audioTranscodeAllowedBitrates.cend());
+	_subsonicTranscodeBitrate = bitrate;
+}
+
+void
+User::clearAuthTokens()
+{
+	_authTokens.clear();
+}
+
+TrackList::pointer
+User::getQueuedTrackList(Session& session) const
+{
+	assert(self());
+	session.checkSharedLocked();
+
+	return TrackList::get(session, queuedListName, TrackList::Type::Internal, self());
+}
+
+void
+User::starArtist(ObjectPtr<Artist> artist)
+{
+	if (_starredArtists.count(getDboPtr(artist)) == 0)
+		_starredArtists.insert(getDboPtr(artist));
+}
+
+void
+User::unstarArtist(ObjectPtr<Artist> artist)
+{
+	if (_starredArtists.count(getDboPtr(artist)) != 0)
+		_starredArtists.erase(getDboPtr(artist));
+}
+
+bool
+User::hasStarredArtist(ObjectPtr<Artist> artist) const
+{
+	return _starredArtists.count(getDboPtr(artist)) != 0;
+}
+
+void
+User::starRelease(ObjectPtr<Release> release)
+{
+	if (_starredReleases.count(getDboPtr(release)) == 0)
+		_starredReleases.insert(getDboPtr(release));
+}
+
+void
+User::unstarRelease(ObjectPtr<Release> release)
+{
+	if (_starredReleases.count(getDboPtr(release)) != 0)
+		_starredReleases.erase(getDboPtr(release));
+}
+
+bool
+User::hasStarredRelease(ObjectPtr<Release> release) const
+{
+	return _starredReleases.count(getDboPtr(release)) != 0;
+}
+
+void
+User::starTrack(ObjectPtr<Track> track)
+{
+	if (_starredTracks.count(getDboPtr(track)) == 0)
+		_starredTracks.insert(getDboPtr(track));
+}
+
+void
+User::unstarTrack(ObjectPtr<Track> track)
+{
+	if (_starredTracks.count(getDboPtr(track)) != 0)
+		_starredTracks.erase(getDboPtr(track));
+}
+
+bool
+User::hasStarredTrack(ObjectPtr<Track> track) const
+{
+	return _starredTracks.count(getDboPtr(track)) != 0;
+}
+
+} // namespace Database
+
+

src/libs/services/database/impl/Utils.cpp

@@ -0,0 +1,33 @@
+/*
+ * 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 "utils/String.hpp"
+
+namespace Database
+{
+	std::string
+	escapeLikeKeyword(std::string_view keyword)
+	{
+		return StringUtils::escapeString(keyword, "%_", escapeChar);
+	}
+
+} // namespace Database
+

src/libs/services/database/impl/Utils.hpp

@@ -0,0 +1,33 @@
+/*
+ * 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 <string_view>
+#include <vector>
+
+namespace Database
+{
+#define ESCAPE_CHAR_STR "\\"
+	static constexpr char escapeChar {'\\'};
+	std::string escapeLikeKeyword(std::string_view keywords);
+
+} // namespace Database
+

src/libs/services/database/include/database/Artist.hpp

@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2015 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 <string>
+#include <string_view>
+#include <vector>
+
+#include <Wt/WDateTime.h>
+#include <Wt/Dbo/Dbo.h>
+
+#include "database/Types.hpp"
+#include "utils/EnumSet.hpp"
+#include "utils/UUID.hpp"
+
+namespace Database
+{
+
+class Cluster;
+class ClusterType;
+class Release;
+class Session;
+class Track;
+class TrackArtistLink;
+class User;
+
+class Artist : public Object<Artist, ArtistId>
+{
+	public:
+		enum class SortMethod
+		{
+			None,
+			ByName,
+			BySortName,
+		};
+
+		Artist() = default;
+		Artist(const std::string& name, const std::optional<UUID>& MBID = {});
+
+		// Accessors
+		static pointer			getByMBID(Session& session, const UUID& MBID);
+		static pointer			getById(Session& session, ArtistId id);
+		static bool				exists(Session& session, ArtistId id);
+		static std::vector<pointer>	getByName(Session& session, const std::string& name);		// exact match on name field
+		static std::vector<pointer> getByClusters(Session& session,
+								const std::vector<ClusterId>& clusters,		// at least one track that belongs to  these clusters
+								SortMethod sortMethod
+								);
+		static std::vector<pointer> 	getByFilter(Session& session,
+								const std::vector<ClusterId>& clusters,			// if non empty, at least one artist that belongs to these clusters
+								const std::vector<std::string_view>& keywords,	// if non empty, name must match all of these keywords (name + sort name fields)
+								std::optional<TrackArtistLinkType> linkType, 	// if set, only artists that have produced at least one track with this link type
+								SortMethod sortMethod,
+								std::optional<Range> range,
+								bool& moreExpected);
+
+		static std::vector<pointer>		getAll(Session& session);
+		static std::vector<pointer>		getAll(Session& session, SortMethod sortMethod);
+		static std::vector<pointer>		getAll(Session& session, SortMethod sortMethod, std::optional<Range> range, bool& moreResults);
+		static std::vector<ArtistId>	getAllIds(Session& session);
+		static std::vector<ArtistId>	getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<TrackArtistLinkType> linkType, std::optional<std::size_t> size = {});
+		static std::vector<pointer>		getAllOrphans(Session& session); // No track related
+		static std::vector<pointer>		getLastWritten(Session& session,
+								std::optional<Wt::WDateTime> after,
+								const std::vector<ClusterId>& clusters,
+								std::optional<TrackArtistLinkType> linkType, 	// if set, only artists that have produced at least one track with this link type
+								std::optional<Range>,
+								bool& moreResults);
+		static std::vector<ArtistId>	getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit = {});
+		static std::vector<pointer>	getStarred(Session& session,
+								ObjectPtr<User> user,
+								const std::vector<ClusterId>& clusters,
+								std::optional<TrackArtistLinkType> linkType, 	// if set, only artists that have produced at least one track with this link type
+								SortMethod sortMethod,
+								std::optional<Range>, bool& moreResults);
+
+		// Accessors
+		const std::string&	getName() const { return _name; }
+		const std::string&	getSortName() const { return _sortName; }
+		std::optional<UUID>	getMBID() const { return UUID::fromString(_MBID); }
+
+		std::vector<ObjectPtr<Release>>	getReleases(const std::vector<ClusterId>& clusterIds = {}) const; // if non empty, get the releases that match all these clusters
+		std::size_t							getReleaseCount() const;
+		std::vector<ObjectPtr<Track>>		getTracks(std::optional<TrackArtistLinkType> linkType = {}) const;
+		bool								hasNonReleaseTracks(std::optional<TrackArtistLinkType> linkType = std::nullopt) const;
+		std::vector<ObjectPtr<Track>>		getNonReleaseTracks(std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
+		std::vector<ObjectPtr<Track>>		getRandomTracks(std::optional<std::size_t> count) const;
+
+		// No artistLinkTypes means get them all
+		std::vector<pointer>				getSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes = {}, std::optional<Range> range = std::nullopt) 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);
+
+		// Create
+		static pointer	create(Session& session, const std::string& name, const std::optional<UUID>& UUID = {});
+
+		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, _starringUsers, Wt::Dbo::ManyToMany, "user_release_starred", "", Wt::Dbo::OnDeleteCascade);
+			}
+
+	private:
+
+		static const std::size_t _maxNameLength = 128;
+
+		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<User>>		_starringUsers; // Users that starred this artist
+};
+
+} // namespace Database
+

src/libs/services/database/include/database/Cluster.hpp

@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2018 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 <string_view>
+#include <vector>
+
+#include <Wt/Dbo/Dbo.h>
+#include <Wt/WDateTime.h>
+
+#include "database/Types.hpp"
+
+namespace Database {
+
+class Track;
+class ClusterType;
+class ScanSettings;
+class Session;
+
+class Cluster : public Object<Cluster, ClusterId>
+{
+	public:
+		Cluster() = default;
+		Cluster(ObjectPtr<ClusterType> type, std::string_view name);
+
+		// Find utility
+		static std::vector<pointer> getAll(Session& session);
+		static std::vector<pointer> getAllOrphans(Session& session);
+		static pointer getById(Session& session, ClusterId id);
+
+		// Create utility
+		static pointer create(Session& session, ObjectPtr<ClusterType> type, std::string_view name);
+
+		// Accessors
+		const std::string& getName() const		{ return _name; }
+		ObjectPtr<ClusterType> getType() const	{ return _clusterType; }
+		std::size_t getTracksCount() const		{ return _tracks.size(); }
+		std::vector<ObjectPtr<Track>> getTracks(std::optional<std::size_t> offset = {}, std::optional<std::size_t> limit = {}) const;
+		std::vector<TrackId> getTrackIds() const;
+		std::size_t getReleasesCount() const;
+
+		void addTrack(ObjectPtr<Track> track);
+
+		template<class Action>
+		void persist(Action& a)
+		{
+			Wt::Dbo::field(a, _name,	"name");
+
+			Wt::Dbo::belongsTo(a, _clusterType, "cluster_type", Wt::Dbo::OnDeleteCascade);
+			Wt::Dbo::hasMany(a, _tracks, Wt::Dbo::ManyToMany, "track_cluster", "", Wt::Dbo::OnDeleteCascade);
+		}
+
+	private:
+		static const std::size_t _maxNameLength = 128;
+
+		std::string	_name;
+
+		Wt::Dbo::ptr<ClusterType> _clusterType;
+		Wt::Dbo::collection< Wt::Dbo::ptr<Track> > _tracks;
+};
+
+
+class ClusterType : public Object<ClusterType, ClusterTypeId>
+{
+	public:
+		ClusterType() = default;
+		ClusterType(std::string_view name);
+
+		// Getters
+		static std::vector<pointer> getAllOrphans(Session& session);
+		static std::vector<pointer> getAllUsed(Session& session);
+		static pointer getByName(Session& session, const std::string& name);
+		static pointer getById(Session& session, ClusterTypeId id);
+		static std::vector<pointer> getAll(Session& session);
+
+		static pointer create(Session& session, const std::string& name);
+		static void remove(Session& session, const std::string& name);
+
+		// Accessors
+		const std::string& getName(void) const { return _name; }
+		std::vector<Cluster::pointer> getClusters() const;
+		Cluster::pointer getCluster(const std::string& name) const;
+
+		template<class Action>
+		void persist(Action& a)
+		{
+			Wt::Dbo::field(a, _name,	"name");
+			Wt::Dbo::hasMany(a, _clusters, Wt::Dbo::ManyToOne, "cluster_type");
+			Wt::Dbo::belongsTo(a, _scanSettings, "scan_settings", Wt::Dbo::OnDeleteCascade);
+		}
+
+	private:
+
+		static const std::size_t _maxNameLength = 128;
+
+		std::string     _name;
+		Wt::Dbo::collection< Wt::Dbo::ptr<Cluster> > _clusters;
+		Wt::Dbo::ptr<ScanSettings> _scanSettings;
+};
+
+} // namespace Database
+

src/libs/services/database/include/database/Db.hpp

@@ -0,0 +1,101 @@
+/*
+ * 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 <filesystem>
+
+#include <Wt/Dbo/SqlConnectionPool.h>
+
+#include "utils/RecursiveSharedMutex.hpp"
+
+namespace Database {
+
+class Session;
+class Db
+{
+	public:
+
+		Db(const std::filesystem::path& dbPath, std::size_t connectionCount = 10);
+		~Db();
+
+		Db(const Db&) = delete;
+		Db(Db&&) = delete;
+		Db& operator=(const Db&) = delete;
+		Db& operator=(Db&&) = delete;
+
+		Session& getTLSSession();
+
+	private:
+		friend class Session;
+
+		RecursiveSharedMutex&		getMutex() { return _sharedMutex; }
+		Wt::Dbo::SqlConnectionPool&	getConnectionPool() { return *_connectionPool; }
+
+		class ScopedConnection
+		{
+			public:
+				ScopedConnection(Wt::Dbo::SqlConnectionPool& pool);
+				~ScopedConnection();
+
+				ScopedConnection(const ScopedConnection& ) = delete;
+				ScopedConnection(ScopedConnection&& ) = delete;
+				ScopedConnection& operator=(const ScopedConnection& ) = delete;
+				ScopedConnection& operator=(ScopedConnection&& ) = delete;
+
+				Wt::Dbo::SqlConnection* operator->() const;
+
+			private:
+				Wt::Dbo::SqlConnectionPool& _connectionPool;
+				std::unique_ptr<Wt::Dbo::SqlConnection> _connection;
+		};
+
+		class ScopedNoForeignKeys
+		{
+			public:
+				ScopedNoForeignKeys(Db& db) : _db {db}
+				{
+					_db.executeSql("PRAGMA foreign_keys=OFF");
+				}
+				~ScopedNoForeignKeys()
+				{
+					_db.executeSql("PRAGMA foreign_keys=ON");
+				}
+
+				ScopedNoForeignKeys(const ScopedNoForeignKeys&) = delete;
+				ScopedNoForeignKeys(ScopedNoForeignKeys&&) = delete;
+				ScopedNoForeignKeys& operator=(const ScopedNoForeignKeys&) = delete;
+				ScopedNoForeignKeys& operator=(ScopedNoForeignKeys&&) = delete;
+
+			private:
+				Db& _db;
+		};
+
+		void executeSql(const std::string& sql);
+
+		RecursiveSharedMutex				_sharedMutex;
+		std::unique_ptr<Wt::Dbo::SqlConnectionPool>	_connectionPool;
+
+		std::mutex _tlsSessionsMutex;
+		std::vector<std::unique_ptr<Session>> _tlsSessions;
+};
+
+} // namespace Database
+
+

src/libs/services/database/include/database/Release.hpp

@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2015 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 <vector>
+
+#include <Wt/WDateTime.h>
+#include <Wt/Dbo/Dbo.h>
+
+#include "database/Types.hpp"
+#include "utils/UUID.hpp"
+
+namespace Database
+{
+
+class Artist;
+class Cluster;
+class ClusterType;
+class Release;
+class Session;
+class Track;
+class User;
+
+class Release : public Object<Release, ReleaseId>
+{
+	public:
+		Release() = default;
+		Release(const std::string& name, const std::optional<UUID>& MBID = {});
+
+		// Accessors
+		static std::size_t		getCount(Session& session);
+		static pointer			getByMBID(Session& session, const UUID& MBID);
+		static std::vector<pointer>	getByName(Session& session, const std::string& name);
+		static pointer			getById(Session& session, ReleaseId id);
+		static bool				exists(Session& session, ReleaseId id);
+		static std::vector<pointer>	getAllOrphans(Session& session); // no track related
+		static std::vector<pointer>	getAll(Session& session, std::optional<Range> range = std::nullopt);
+		static std::vector<ReleaseId>	getAllIds(Session& session);
+		static std::vector<pointer>	getAllOrderedByArtist(Session& session, std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {});
+		static std::vector<pointer>	getAllRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<std::size_t> size = {});
+		static std::vector<ReleaseId>	getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<std::size_t> size = {});
+		static std::vector<pointer>	getLastWritten(Session& session, std::optional<Wt::WDateTime> after, const std::vector<ClusterId>& clusters, std::optional<Range> range, bool& moreResults);
+		static std::vector<pointer>	getByYear(Session& session, int yearFrom, int yearTo, std::optional<Range> range = std::nullopt);
+		static std::vector<pointer> getStarred(Session& session, ObjectPtr<User> user, const std::vector<ClusterId>& clusters, std::optional<Range> range, bool& moreResults);
+
+		static std::vector<pointer>	getByClusters(Session& session, const std::vector<ClusterId>& clusters);
+		static std::vector<pointer>	getByFilter(Session& session,
+							const std::vector<ClusterId>& clusters,		// if non empty, at least one release that belongs to these clusters
+							const std::vector<std::string_view>& keywords,	// if non empty, name must match all of these keywords
+							std::optional<Range> range,
+							bool& moreExpected);
+		static std::vector<ReleaseId>	getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit = {});
+
+		std::vector<ObjectPtr<Track>> getTracks(const std::vector<ClusterId>& clusters = {}) const;
+		std::size_t					getTracksCount() const;
+		ObjectPtr<Track>			getFirstTrack() const;
+
+		// 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)
+		// size is the max number of cluster per cluster type
+		std::vector<std::vector<ObjectPtr<Cluster>>> getClusterGroups(const std::vector<ObjectPtr<ClusterType>>& clusterTypes, std::size_t size) const;
+
+		// Create
+		static pointer	create(Session& session, const std::string& name, const std::optional<UUID>& MBID = {});
+
+		// Utility functions
+		std::optional<int>			getReleaseYear(bool originalDate = false) const;
+		std::optional<std::string>	getCopyright() const;
+		std::optional<std::string>	getCopyrightURL() const;
+
+		// Accessors
+		const std::string&		getName() const		{ return _name; }
+		std::optional<UUID>		getMBID() const		{ return UUID::fromString(_MBID); }
+		std::optional<std::size_t>	getTotalTrack() const;
+		std::optional<std::size_t>	getTotalDisc() const;
+		std::chrono::milliseconds	getDuration() const;
+		Wt::WDateTime				getLastWritten() const;
+
+		// Get the artists of this release
+		std::vector<ObjectPtr<Artist> > getArtists(TrackArtistLinkType type = TrackArtistLinkType::Artist) const;
+		std::vector<ObjectPtr<Artist> > getReleaseArtists() const { return getArtists(TrackArtistLinkType::ReleaseArtist); }
+		bool hasVariousArtists() const;
+		std::vector<pointer>		getSimilarReleases(std::optional<std::size_t> offset = {}, std::optional<std::size_t> count = {}) const;
+
+		void setName(std::string_view name)		{ _name = name; }
+		void setMBID(const std::optional<UUID>& mbid)	{ _MBID = mbid ? mbid->getAsString() : ""; }
+
+		template<class Action>
+			void persist(Action& a)
+			{
+				Wt::Dbo::field(a, _name, "name");
+				Wt::Dbo::field(a, _MBID, "mbid");
+
+				Wt::Dbo::hasMany(a, _tracks, Wt::Dbo::ManyToOne, "release");
+				Wt::Dbo::hasMany(a, _starringUsers, Wt::Dbo::ManyToMany, "user_release_starred", "", Wt::Dbo::OnDeleteCascade);
+			}
+
+	private:
+		static const std::size_t _maxNameLength {128};
+
+		std::string	_name;
+		std::string	_MBID;
+
+		Wt::Dbo::collection<Wt::Dbo::ptr<Track>>	_tracks; // Tracks in the release
+		Wt::Dbo::collection<Wt::Dbo::ptr<User>>		_starringUsers; // Users that starred this release
+};
+
+} // namespace Database
+
+

src/libs/services/database/include/database/ScanSettings.hpp

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2018 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 <filesystem>
+#include <vector>
+
+#include <Wt/Dbo/Dbo.h>
+#include <Wt/WTime.h>
+
+#include "database/Types.hpp"
+
+namespace Database {
+
+class ClusterType;
+class Session;
+
+class ScanSettings : 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,
+		};
+
+		static void init(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; }
+
+		// 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();
+
+		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");
+		}
+
+	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"};
+		Wt::Dbo::collection<Wt::Dbo::ptr<ClusterType>>	_clusterTypes;
+};
+
+
+} // namespace Database
+

src/libs/services/database/include/database/Session.hpp

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2013 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 <mutex>
+
+#include <Wt/Dbo/Dbo.h>
+#include <Wt/Dbo/SqlConnectionPool.h>
+
+#include "utils/RecursiveSharedMutex.hpp"
+
+namespace Database
+{
+
+	class UniqueTransaction
+	{
+		private:
+			friend class Session;
+			UniqueTransaction(RecursiveSharedMutex& mutex, Wt::Dbo::Session& session);
+
+			std::unique_lock<RecursiveSharedMutex> _lock;
+			Wt::Dbo::Transaction _transaction;
+	};
+
+	class SharedTransaction
+	{
+		private:
+			friend class Session;
+			SharedTransaction(RecursiveSharedMutex& mutex, Wt::Dbo::Session& session);
+
+			std::shared_lock<RecursiveSharedMutex> _lock;
+			Wt::Dbo::Transaction _transaction;
+	};
+
+	class Db;
+	class Session
+	{
+		public:
+			Session (Db& database);
+
+			Session(const Session&) = delete;
+			Session(Session&&) = delete;
+			Session& operator=(const Session&) = delete;
+			Session& operator=(Session&&) = delete;
+
+			[[nodiscard]] UniqueTransaction createUniqueTransaction();
+			[[nodiscard]] SharedTransaction createSharedTransaction();
+
+			void checkUniqueLocked();
+			void checkSharedLocked();
+
+			void optimize();
+
+			void prepareTables(); // need to run only once at startup
+
+			Wt::Dbo::Session& getDboSession() { return _session; }
+
+		private:
+			Session(std::shared_mutex& mutex, Wt::Dbo::SqlConnectionPool& connectionPool);
+
+			void doDatabaseMigrationIfNeeded();
+
+			Db&					_db;
+			Wt::Dbo::Session	_session;
+	};
+
+} // namespace Database
+
+

src/libs/services/database/include/database/Track.hpp

@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2013-2016 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 <filesystem>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_set>
+#include <vector>
+
+#include <Wt/WDateTime.h>
+#include <Wt/Dbo/Dbo.h>
+#include <Wt/Dbo/WtSqlTraits.h>
+
+#include "utils/EnumSet.hpp"
+#include "utils/UUID.hpp"
+
+#include "database/Types.hpp"
+
+namespace Database {
+
+class Artist;
+class Cluster;
+class ClusterType;
+class Release;
+class Session;
+class TrackArtistLink;
+class TrackFeatures;
+class TrackListEntry;
+class TrackStats;
+class User;
+
+class Track : public Object<Track, TrackId>
+{
+	public:
+		Track() = default;
+		Track(const std::filesystem::path& p);
+
+		// Find utility functions
+		static std::size_t			getCount(Session& session);
+		static pointer				getByPath(Session& session, const std::filesystem::path& p);
+		static pointer 				getById(Session& session, TrackId id);
+		static bool					exists(Session& session, TrackId id);
+		static std::vector<pointer> getByRecordingMBID(Session& session, const UUID& MBID);
+		static std::vector<pointer>	getSimilarTracks(Session& session,
+							const std::vector<TrackId>& trackIds,
+							std::optional<std::size_t> offset = {},
+							std::optional<std::size_t> size = {});
+		static std::vector<pointer>	getByClusters(Session& session,
+							const std::vector<ClusterId>& clusters);           // tracks that belong to these clusters
+		static std::vector<pointer>	getByFilter(Session& session,
+							const std::vector<ClusterId>& clusters,            // if non empty, tracks that belong to these clusters
+							const std::vector<std::string_view>& keywords,    // if non empty, name must match all of these keywords
+							std::optional<Range> range,
+							bool& moreExpected);
+		static std::vector<pointer> getByNameAndReleaseName(Session& session, std::string_view trackName, std::string_view releaseName);
+
+		static std::vector<pointer>	getAll(Session& session, std::optional<std::size_t> limit = std::nullopt);
+		static std::vector<pointer>	getAllRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<std::size_t> limit = std::nullopt);
+		static std::vector<TrackId>	getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<std::size_t> limit = std::nullopt);
+		static std::vector<TrackId>	getAllIds(Session& session);
+		static std::vector<std::pair<TrackId, std::filesystem::path>> getAllPaths(Session& session, std::optional<std::size_t> offset = std::nullopt, std::optional<std::size_t> size = std::nullopt);
+		static std::vector<pointer>	getMBIDDuplicates(Session& session);
+		static std::vector<pointer>	getLastWritten(Session& session, std::optional<Wt::WDateTime> after, const std::vector<ClusterId>& clusters, std::optional<Range> range, bool& moreResults);
+		static std::vector<pointer>	getAllWithRecordingMBIDAndMissingFeatures(Session& session);
+		static std::vector<TrackId>	getAllIdsWithFeatures(Session& session, std::optional<std::size_t> limit = {});
+		static std::vector<TrackId>	getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit = {});
+		static std::vector<pointer>	getStarred(Session& session,
+							ObjectPtr<User> user,
+							const std::vector<ClusterId>& clusters,
+							std::optional<Range> range, bool& hasMore);
+
+		// Create utility
+		static pointer	create(Session& session, const std::filesystem::path& p);
+
+		// Accessors
+		void setScanVersion(std::size_t version)			{ _scanVersion = version; }
+		void setTrackNumber(int num)					{ _trackNumber = num; }
+		void setDiscNumber(int num)					{ _discNumber = num; }
+		void setTotalTrack(std::optional<int> totalTrack)		{ _totalTrack = totalTrack ? *totalTrack : 0; }
+		void setTotalDisc(std::optional<int> totalDisc)			{ _totalDisc = totalDisc ? *totalDisc : 0; }
+		void setDiscSubtitle(const std::string& name)			{ _discSubtitle = name; }
+		void setName(const std::string& name)				{ _name = std::string(name, 0, _maxNameLength); }
+		void setDuration(std::chrono::milliseconds duration)		{ _duration = duration; }
+		void setLastWriteTime(Wt::WDateTime time)			{ _fileLastWrite = time; }
+		void setAddedTime(Wt::WDateTime time)				{ _fileAdded = time; }
+		void setDate(const Wt::WDate& date)							{ _date = date; }
+		void setOriginalDate(const Wt::WDate& date)					{ _originalDate = date; }
+		void setHasCover(bool hasCover)					{ _hasCover = hasCover; }
+		void setTrackMBID(const std::optional<UUID>& MBID)			{ _trackMBID = MBID ? MBID->getAsString() : ""; }
+		void setRecordingMBID(const std::optional<UUID>& MBID)		{ _recordingMBID = MBID ? MBID->getAsString() : ""; }
+		void setCopyright(const std::string& copyright)			{ _copyright = std::string(copyright, 0, _maxCopyrightLength); }
+		void setCopyrightURL(const std::string& copyrightURL)		{ _copyrightURL = std::string(copyrightURL, 0, _maxCopyrightURLLength); }
+		void setTrackReplayGain(std::optional<float> replayGain)			{ _trackReplayGain = replayGain; }
+		void setReleaseReplayGain(std::optional<float> replayGain)			{ _releaseReplayGain = replayGain; }
+		void clearArtistLinks();
+		void addArtistLink(const ObjectPtr<TrackArtistLink>& artistLink);
+		void setRelease(ObjectPtr<Release> release)			{ _release = getDboPtr(release); }
+		void setClusters(const std::vector<ObjectPtr<Cluster>>& clusters );
+		void setFeatures(const ObjectPtr<TrackFeatures>& features);
+
+		std::size_t 				getScanVersion() const		{ return _scanVersion; }
+		std::optional<std::size_t>	getTrackNumber() const;
+		std::optional<std::size_t>	getTotalTrack() const;
+		std::optional<std::size_t>	getDiscNumber() const;
+		const std::string&			getDiscSubtitle() const { return _discSubtitle; }
+		std::optional<std::size_t>	getTotalDisc() const;
+		std::string 				getName() const			{ return _name; }
+		std::filesystem::path		getPath() const			{ return _filePath; }
+		std::chrono::milliseconds	getDuration() const		{ return _duration; }
+		const Wt::WDateTime&		getLastWritten() const	{ return _fileLastWrite; }
+		std::optional<int>			getYear() const;
+		std::optional<int>			getOriginalYear() const;
+		Wt::WDateTime				getLastWriteTime() const	{ return _fileLastWrite; }
+		Wt::WDateTime				getAddedTime() const		{ return _fileAdded; }
+		bool						hasCover() const		{ return _hasCover; }
+		std::optional<UUID>			getTrackMBID() const			{ return UUID::fromString(_trackMBID); }
+		std::optional<UUID>			getRecordingMBID() const			{ return UUID::fromString(_recordingMBID); }
+		std::optional<std::string>	getCopyright() const;
+		std::optional<std::string>	getCopyrightURL() const;
+		std::optional<float>		getTrackReplayGain() const	{ return _trackReplayGain; }
+		std::optional<float>		getReleaseReplayGain() const	{ return _releaseReplayGain; }
+
+		// no artistLinkTypes means get all
+		std::vector<ObjectPtr<Artist>>	getArtists(EnumSet<TrackArtistLinkType> artistLinkTypes) const;
+		std::vector<ArtistId>				getArtistIds(EnumSet<TrackArtistLinkType> artistLinkTypes) const;
+		std::vector<ObjectPtr<TrackArtistLink>>	getArtistLinks() const;
+		ObjectPtr<Release>				getRelease() const		{ return _release; }
+		std::vector<ObjectPtr<Cluster>>	getClusters() const;
+		std::vector<ClusterId>				getClusterIds() const;
+		bool								hasTrackFeatures() const;
+		ObjectPtr<TrackFeatures>			getTrackFeatures() const;
+
+		std::vector<std::vector<ObjectPtr<Cluster>>> getClusterGroups(const std::vector<ObjectPtr<ClusterType>>& clusterTypes, std::size_t size) const;
+
+		template<class Action>
+			void persist(Action& a)
+			{
+				Wt::Dbo::field(a, _scanVersion,		"scan_version");
+				Wt::Dbo::field(a, _trackNumber,		"track_number");
+				Wt::Dbo::field(a, _discNumber,		"disc_number");
+				Wt::Dbo::field(a, _discSubtitle,	"disc_subtitle");
+				Wt::Dbo::field(a, _totalTrack,		"total_track");
+				Wt::Dbo::field(a, _totalDisc,		"total_disc");
+				Wt::Dbo::field(a, _name,			"name");
+				Wt::Dbo::field(a, _duration,		"duration");
+				Wt::Dbo::field(a, _date,			"date");
+				Wt::Dbo::field(a, _originalDate,	"original_date");
+				Wt::Dbo::field(a, _filePath,		"file_path");
+				Wt::Dbo::field(a, _fileLastWrite,	"file_last_write");
+				Wt::Dbo::field(a, _fileAdded,		"file_added");
+				Wt::Dbo::field(a, _hasCover,		"has_cover");
+				Wt::Dbo::field(a, _trackMBID,		"mbid");
+				Wt::Dbo::field(a, _recordingMBID,	"recording_mbid");
+				Wt::Dbo::field(a, _copyright,		"copyright");
+				Wt::Dbo::field(a, _copyrightURL,	"copyright_url");
+				Wt::Dbo::field(a, _trackReplayGain,	"track_replay_gain");
+				Wt::Dbo::field(a, _releaseReplayGain,	"release_replay_gain");
+				Wt::Dbo::belongsTo(a, _release, "release", Wt::Dbo::OnDeleteCascade);
+				Wt::Dbo::hasMany(a, _trackArtistLinks, Wt::Dbo::ManyToOne, "track");
+				Wt::Dbo::hasMany(a, _clusters, Wt::Dbo::ManyToMany, "track_cluster", "", Wt::Dbo::OnDeleteCascade);
+				Wt::Dbo::hasMany(a, _playlistEntries, Wt::Dbo::ManyToOne, "track");
+				Wt::Dbo::hasMany(a, _starringUsers, Wt::Dbo::ManyToMany, "user_track_starred", "", Wt::Dbo::OnDeleteCascade);
+				Wt::Dbo::hasOne(a, _trackFeatures);
+			}
+
+	private:
+
+		static const std::size_t _maxNameLength = 128;
+		static const std::size_t _maxCopyrightLength = 128;
+		static const std::size_t _maxCopyrightURLLength = 128;
+
+		int						_scanVersion {};
+		int						_trackNumber {};
+		int						_discNumber {};
+		std::string				_discSubtitle;
+		int						_totalTrack {};
+		int						_totalDisc {};
+		std::string				_name;
+		std::string				_artistName;
+		std::string				_releaseName;
+		std::chrono::duration<int, std::milli>	_duration {};
+		Wt::WDate				_date;
+		Wt::WDate				_originalDate;
+		std::string				_filePath;
+		Wt::WDateTime			_fileLastWrite;
+		Wt::WDateTime			_fileAdded;
+		bool					_hasCover {};
+		std::string				_trackMBID;
+		std::string				_recordingMBID;
+		std::string				_copyright;
+		std::string				_copyrightURL;
+		std::optional<float>	_trackReplayGain;
+		std::optional<float>	_releaseReplayGain;
+
+		Wt::Dbo::ptr<Release>				_release;
+		Wt::Dbo::collection<Wt::Dbo::ptr<TrackArtistLink>> _trackArtistLinks;
+		Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> 	_clusters;
+		Wt::Dbo::collection<Wt::Dbo::ptr<TrackListEntry>> _playlistEntries;
+		Wt::Dbo::collection<Wt::Dbo::ptr<User>>		_starringUsers;
+		Wt::Dbo::weak_ptr<TrackFeatures>		_trackFeatures;
+
+};
+
+} // namespace database
+
+

src/libs/services/database/include/database/TrackArtistLink.hpp

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2013-2016 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 <Wt/Dbo/Dbo.h>
+
+#include "database/Types.hpp"
+#include "utils/EnumSet.hpp"
+
+namespace Database
+{
+
+	class Artist;
+	class Session;
+	class Track;
+
+	class TrackArtistLink : public Object<TrackArtistLink, TrackArtistLinkId>
+	{
+		public:
+			TrackArtistLink() = default;
+			TrackArtistLink(ObjectPtr<Track> track, ObjectPtr<Artist> artist, TrackArtistLinkType type);
+
+			static pointer create(Session& session, ObjectPtr<Track> track, ObjectPtr<Artist> artist, TrackArtistLinkType type);
+
+			static EnumSet<TrackArtistLinkType> getUsedTypes(Session& session);
+
+			ObjectPtr<Track>		getTrack() const { return _track; }
+			ObjectPtr<Artist>	getArtist() const { return _artist; }
+			TrackArtistLinkType		getType() const { return _type; }
+
+			template<class Action>
+				void persist(Action& a)
+				{
+					Wt::Dbo::field(a, _type, "type");
+					Wt::Dbo::field(a, _type, "name");
+
+					Wt::Dbo::belongsTo(a, _track, "track", Wt::Dbo::OnDeleteCascade);
+					Wt::Dbo::belongsTo(a, _artist, "artist", Wt::Dbo::OnDeleteCascade);
+				}
+
+		private:
+			TrackArtistLinkType _type;
+			std::string	_name;
+
+			Wt::Dbo::ptr<Track> _track;
+			Wt::Dbo::ptr<Artist> _artist;
+	};
+
+}
+

src/libs/services/database/include/database/TrackBookmark.hpp

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2020 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 <Wt/Dbo/Dbo.h>
+
+#include "database/Types.hpp"
+
+namespace Database {
+
+class Session;
+class Track;
+class User;
+
+class TrackBookmark : public Object<TrackBookmark, TrackBookmarkId>
+{
+	public:
+		TrackBookmark () = default;
+		TrackBookmark(ObjectPtr<User> user, ObjectPtr<Track> track);
+
+		// utility
+		static pointer create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track);
+
+		// Find utility functions
+		static std::vector<pointer>	getAll(Session& session);
+		static std::vector<pointer>	getByUser(Session& session, ObjectPtr<User> user);
+		static pointer			getByUser(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track);
+		static pointer			getById(Session& session, TrackBookmarkId id);
+
+		// Setters
+		void setOffset(std::chrono::milliseconds offset)	{ _offset = offset; }
+		void setComment(std::string_view comment)		{ _comment = comment; }
+
+		// Getters
+		std::chrono::milliseconds	getOffset() const	{ return _offset; }
+		std::string_view		getComment() const	{ return _comment; }
+		ObjectPtr<Track>		getTrack() const	{ return _track; }
+		ObjectPtr<User>		getUser() const		{ return _user; }
+
+		template<class Action>
+			void persist(Action& a)
+			{
+				Wt::Dbo::field(a, _offset,		"offset");
+				Wt::Dbo::field(a, _comment,		"comment");
+				Wt::Dbo::belongsTo(a, _track, 		"track", Wt::Dbo::OnDeleteCascade);
+				Wt::Dbo::belongsTo(a, _user, 		"user", Wt::Dbo::OnDeleteCascade);
+			}
+	private:
+
+		static const std::size_t _maxCommentLength = 128;
+
+		std::chrono::duration<int, std::milli>	_offset;
+		std::string				_comment;
+
+		Wt::Dbo::ptr<User>			_user;
+		Wt::Dbo::ptr<Track>			_track;
+};
+
+} // namespace database
+
+

src/libs/services/database/include/database/TrackFeatures.hpp

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2018 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 <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include <Wt/Dbo/Dbo.h>
+
+#include "database/Types.hpp"
+
+namespace Database {
+
+class Session;
+class Track;
+
+using FeatureName = std::string;
+using FeatureValues  = std::vector<double>;
+using FeatureValuesMap = std::unordered_map<FeatureName, FeatureValues>;
+
+class TrackFeatures : public Object<TrackFeatures, TrackFeaturesId>
+{
+	public:
+		TrackFeatures() = default;
+		TrackFeatures(ObjectPtr<Track> track, const std::string& jsonEncodedFeatures);
+
+		// Create utility
+		static pointer create(Session& session, ObjectPtr<Track> track, const std::string& jsonEncodedFeatures);
+
+		FeatureValues		getFeatureValues(const FeatureName& feature) const;
+		FeatureValuesMap	getFeatureValuesMap(const std::unordered_set<FeatureName>& featureNames) const;
+
+		template<class Action>
+		void persist(Action& a)
+		{
+			Wt::Dbo::field(a, _data,	"data");
+			Wt::Dbo::belongsTo(a, _track, "track", Wt::Dbo::OnDeleteCascade);
+		}
+
+	private:
+
+		std::string _data;
+		Wt::Dbo::ptr<Track> _track;
+};
+
+
+} // namespace database
+
+

src/libs/services/database/include/database/TrackList.hpp

@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2014 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 <string>
+#include <set>
+#include <vector>
+
+#include <Wt/Dbo/Dbo.h>
+#include <Wt/WDateTime.h>
+
+#include "database/Types.hpp"
+
+namespace Database {
+
+class Artist;
+class Cluster;
+class Release;
+class Session;
+class Track;
+class TrackListEntry;
+class User;
+
+class TrackList : public Object<TrackList, TrackListId>
+{
+	public:
+		enum class Type
+		{
+			Playlist,  // user controlled playlists
+			Internal,  // internal usage (current playqueue, history, ...)
+		};
+
+		TrackList() = default;
+		TrackList(std::string_view name, Type type, bool isPublic, ObjectPtr<User> user);
+
+		// Stats utility
+		std::vector<ObjectPtr<Artist>> getTopArtists(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
+		std::vector<ObjectPtr<Release>> getTopReleases(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
+		std::vector<ObjectPtr<Track>> getTopTracks(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
+
+		// Search utility
+		static pointer	get(Session& session, std::string_view name, Type type, ObjectPtr<User> user);
+		static pointer	getById(Session& session, TrackListId tracklistId);
+		static std::vector<pointer> getAll(Session& session);
+		static std::vector<pointer> getAll(Session& session, ObjectPtr<User> user);
+		static std::vector<pointer> getAll(Session& session, ObjectPtr<User> user, Type type);
+
+		// Create utility
+		static pointer	create(Session& session, std::string_view name, Type type, bool isPublic, ObjectPtr<User> user);
+
+		// Accessors
+		std::string	getName() const { return _name; }
+		bool		isPublic() const { return _isPublic; }
+		Type		getType() const { return _type; }
+		ObjectPtr<User> getUser() const { return _user; }
+
+		// Modifiers
+		void		setName(const std::string& name) { _name = name; }
+		void		setIsPublic(bool isPublic) { _isPublic = isPublic; }
+		void		clear() { _entries.clear(); }
+
+		// Get tracks, ordered by position
+		bool										isEmpty() const;
+		std::size_t									getCount() const;
+		ObjectPtr<TrackListEntry>					getEntry(std::size_t pos) const;
+		std::vector<ObjectPtr<TrackListEntry>>	getEntries(std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {}) const;
+		ObjectPtr<TrackListEntry>					getEntryByTrackAndDateTime(ObjectPtr<Track> track, const Wt::WDateTime& dateTime) const;
+
+		// Get track bya
+
+		std::vector<ObjectPtr<Artist>>	getArtistsReverse(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
+		std::vector<ObjectPtr<Release>>	getReleasesReverse(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
+		std::vector<ObjectPtr<Track>>		getTracksReverse(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
+
+		std::vector<TrackId> getTrackIds() const;
+
+		std::chrono::milliseconds getDuration() const;
+
+		// Get clusters, order by occurence
+		std::vector<ObjectPtr<Cluster>> getClusters() const;
+
+		bool hasTrack(TrackId trackId) const;
+
+		// Ordered from most clusters in common
+		std::vector<ObjectPtr<Track>> getSimilarTracks(std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {}) const;
+
+		template<class Action>
+		void persist(Action& a)
+		{
+			Wt::Dbo::field(a,	_name,		"name");
+			Wt::Dbo::field(a,	_type,		"type");
+			Wt::Dbo::field(a,	_isPublic,	"public");
+
+			Wt::Dbo::belongsTo(a,	_user,		"user", Wt::Dbo::OnDeleteCascade);
+			Wt::Dbo::hasMany(a, _entries, Wt::Dbo::ManyToOne, "tracklist");
+		}
+
+	private:
+
+		std::string		_name;
+		Type			_type {Type::Playlist};
+		bool			_isPublic {false};
+
+		Wt::Dbo::ptr<User>	_user;
+		Wt::Dbo::collection<Wt::Dbo::ptr<TrackListEntry>> _entries;
+
+};
+
+class TrackListEntry : public Object<TrackListEntry, TrackListEntryId>
+{
+	public:
+		TrackListEntry() = default;
+		TrackListEntry(ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist, const Wt::WDateTime& dateTime);
+
+		// find utility
+		static pointer getById(Session& session, TrackListEntryId id);
+
+		// Create utility
+		static pointer create(Session& session, ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist, const Wt::WDateTime& dateTime = Wt::WDateTime::currentDateTime());
+
+		// Accessors
+		ObjectPtr<Track>	getTrack() const { return _track; }
+		const Wt::WDateTime& getDateTime() const { return _dateTime; }
+
+		template<class Action>
+		void persist(Action& a)
+		{
+			Wt::Dbo::field(a,		_dateTime,	"date_time");
+
+			Wt::Dbo::belongsTo(a,	_track,		"track",		Wt::Dbo::OnDeleteCascade);
+			Wt::Dbo::belongsTo(a,	_tracklist,	"tracklist",	Wt::Dbo::OnDeleteCascade);
+		}
+
+	private:
+
+		Wt::WDateTime			_dateTime;
+		Wt::Dbo::ptr<Track>		_track;
+		Wt::Dbo::ptr<TrackList>	_tracklist;
+};
+
+} // namespace Database
+

src/libs/services/database/include/database/Types.hpp

@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2015 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 <cstdint>
+#include <cassert>
+#include <functional>
+#include <Wt/Dbo/ptr.h>
+
+namespace Database
+{
+	class IdType
+	{
+		public:
+			using ValueType = Wt::Dbo::dbo_default_traits::IdType;
+
+			IdType() = default;
+			IdType(ValueType id) : _id {id} { assert(isValid()); }
+
+			bool isValid() const { return _id != Wt::Dbo::dbo_default_traits::invalidId(); }
+			std::string toString() const { assert(isValid()); return std::to_string(_id); }
+
+			ValueType getValue() const { return _id; }
+
+			bool operator==(IdType other) const { return other._id == _id; }
+			bool operator!=(IdType other) const { return !(*this == other); }
+			bool operator<(IdType other) const { return other._id < _id; }
+
+		private:
+			Wt::Dbo::dbo_default_traits::IdType _id {Wt::Dbo::dbo_default_traits::invalidId()};
+	};
+
+	struct Range
+	{
+		std::size_t offset {};
+		std::size_t limit {};
+	};
+
+	enum class TrackArtistLinkType
+	{
+		Artist,	// regular artist
+		Arranger,
+		Composer,
+		Conductor,
+		Lyricist,
+		Mixer,
+		Performer,
+		Producer,
+		ReleaseArtist,
+		Remixer,
+		Writer,
+	};
+
+	// User selectable audio file formats
+	// Do not change values
+	enum class AudioFormat
+	{
+		MP3		= 1,
+		OGG_OPUS	= 2,
+		OGG_VORBIS	= 3,
+		WEBM_VORBIS	= 4,
+		MATROSKA_OPUS	= 5,
+	};
+	using Bitrate = std::uint32_t;
+
+	// Do not change enum values!
+	enum class Scrobbler
+	{
+		Internal		= 0,
+		ListenBrainz	= 1,
+	};
+
+	// Do not change enum values!
+	enum class UserType
+	{
+		REGULAR	= 0,
+		ADMIN	= 1,
+		DEMO	= 2,
+	};
+
+	template <typename T>
+	class ObjectPtr
+	{
+		public:
+			ObjectPtr() = default;
+			ObjectPtr(Wt::Dbo::ptr<T> obj) : _obj {obj} {}
+
+			const T* operator->() const { return _obj.get(); }
+			operator bool() const { return _obj.get(); }
+			bool operator!() const { return !_obj.get(); }
+
+			auto modify() { return _obj.modify(); }
+			void remove() { _obj.remove(); }
+
+		private:
+			template <typename, typename> friend class Object;
+			Wt::Dbo::ptr<T> _obj;
+	};
+
+	template <typename T, typename ObjectIdType>
+	class Object : public Wt::Dbo::Dbo<T>
+	{
+		static_assert(std::is_base_of_v<Database::IdType, ObjectIdType>);
+		static_assert(!std::is_same_v<Database::IdType, ObjectIdType>);
+
+		public:
+			using pointer = ObjectPtr<T>;
+			using IdType = ObjectIdType;
+
+			IdType getId() const { return Wt::Dbo::Dbo<T>::self()->Wt::Dbo::template Dbo<T>::id(); }
+
+			// catch some misuses
+			typename Wt::Dbo::dbo_traits<T>::IdType id() const = delete;
+
+		protected:
+			// Can get raw dbo ptr only from Objects
+			template <typename SomeObject>
+			static
+			Wt::Dbo::ptr<SomeObject> getDboPtr(ObjectPtr<SomeObject> ptr) { return ptr._obj; }
+	};
+}
+
+// TODO factorize hash with std::enable_if
+#define LMS_DECLARE_IDTYPE(name) \
+namespace Database { \
+	class name : public IdType \
+	{ \
+		public: \
+			using IdType::IdType; \
+	};\
+} \
+namespace std \
+{ \
+	template<> \
+	class hash<Database::name> \
+	{ \
+		public: \
+			size_t operator()(Database::name id) const \
+			{ \
+				return std::hash<Database::name::ValueType>()(id.getValue()); \
+			} \
+	}; \
+} // ns std
+
+LMS_DECLARE_IDTYPE(ArtistId)
+LMS_DECLARE_IDTYPE(AuthTokenId)
+LMS_DECLARE_IDTYPE(ClusterId)
+LMS_DECLARE_IDTYPE(ClusterTypeId)
+LMS_DECLARE_IDTYPE(ReleaseId)
+LMS_DECLARE_IDTYPE(ScanSettingsId)
+LMS_DECLARE_IDTYPE(TrackArtistLinkId)
+LMS_DECLARE_IDTYPE(TrackBookmarkId)
+LMS_DECLARE_IDTYPE(TrackFeaturesId)
+LMS_DECLARE_IDTYPE(TrackId)
+LMS_DECLARE_IDTYPE(TrackListId)
+LMS_DECLARE_IDTYPE(TrackListEntryId)
+LMS_DECLARE_IDTYPE(UserId)
+
+

src/libs/services/database/include/database/User.hpp

@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2013 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 <string_view>
+#include <vector>
+
+#include <Wt/Dbo/Dbo.h>
+#include <Wt/WDateTime.h>
+
+#include "database/Types.hpp"
+#include "utils/UUID.hpp"
+
+namespace Database {
+
+
+class Artist;
+class Release;
+class Session;
+class TrackList;
+class Track;
+
+class User;
+class AuthToken : public Object<AuthToken, AuthTokenId>
+{
+	public:
+		AuthToken() = default;
+		AuthToken(const std::string& value, const Wt::WDateTime& expiry, ObjectPtr<User> user);
+
+		// Utility
+		static pointer create(Session& session, const std::string& value, const Wt::WDateTime&expiry, ObjectPtr<User> user);
+		static void removeExpiredTokens(Session& session, const Wt::WDateTime& now);
+		static pointer getByValue(Session& session, const std::string& value);
+		static pointer getById(Session& session, AuthTokenId tokenId);
+
+		// Accessors
+		const Wt::WDateTime&	getExpiry() const { return _expiry; }
+		ObjectPtr<User>	getUser() const { return _user; }
+		const std::string&	getValue() const { return _value; }
+
+		template<class Action>
+		void persist(Action& a)
+		{
+			Wt::Dbo::field(a,	_value,		"value");
+			Wt::Dbo::field(a,	_expiry,	"expiry");
+			Wt::Dbo::belongsTo(a,	_user,		"user", Wt::Dbo::OnDeleteCascade);
+		}
+
+	private:
+
+		std::string		_value;
+		Wt::WDateTime		_expiry;
+
+		Wt::Dbo::ptr<User>	_user;
+};
+
+class User : public Object<User, UserId>
+{
+	public:
+		struct PasswordHash
+		{
+			std::string salt;
+			std::string hash;
+		};
+
+		// Do not change enum values!
+		enum class UITheme
+		{
+			Light	= 0,
+			Dark	= 1,
+		};
+
+		// Do not remove values!
+		static inline const std::set<Bitrate>	audioTranscodeAllowedBitrates
+		{
+			64000,
+			96000,
+			128000,
+			192000,
+			320000,
+		};
+
+		// Do not change enum values!
+		enum class SubsonicArtistListMode
+		{
+			AllArtists		= 0,
+			ReleaseArtists	= 1,
+			TrackArtists	= 2,
+		};
+
+		static inline const std::size_t 	MinNameLength {3};
+		static inline const std::size_t 	MaxNameLength {15};
+		static inline const bool		defaultSubsonicTranscodeEnable {true};
+		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};
+
+		User() = default;
+		User(std::string_view loginName);
+
+		// utility
+		static pointer create(Session& session, std::string_view loginName);
+
+		static pointer			getById(Session& session, UserId id);
+		static pointer			getByLoginName(Session& session, std::string_view loginName);
+		static std::vector<pointer>	getAll(Session& session);
+		static std::vector<UserId>	getAllIds(Session& session);
+		static pointer			getDemo(Session& session);
+		static std::size_t		getCount(Session& session);
+
+		// accessors
+		const std::string& getLoginName() const { return _loginName; }
+		PasswordHash getPasswordHash() const { return PasswordHash {_passwordSalt, _passwordHash}; }
+		Wt::WDateTime getLastLogin() const { return _lastLogin; }
+		std::size_t getAuthTokensCount() const { return _authTokens.size(); }
+
+		// write
+		void setLastLogin(const Wt::WDateTime& dateTime)	{ _lastLogin = dateTime; }
+		void setPasswordHash(const PasswordHash& passwordHash)	{ _passwordSalt = passwordHash.salt; _passwordHash = passwordHash.hash; }
+		void setType(UserType type)					{ _type = type; }
+		void setSubsonicTranscodeEnable(bool value) 		{ _subsonicTranscodeEnable = value; }
+		void setSubsonicTranscodeFormat(AudioFormat encoding)	{ _subsonicTranscodeFormat = encoding; }
+		void setSubsonicTranscodeBitrate(Bitrate bitrate);
+		void setCurPlayingTrackPos(std::size_t pos)		{ _curPlayingTrackPos = pos; }
+		void setRadio(bool val)					{ _radio = val; }
+		void setRepeatAll(bool val)				{ _repeatAll = val; }
+		void setUITheme(UITheme uiTheme)			{ _uiTheme = uiTheme; }
+		void clearAuthTokens();
+		void setSubsonicArtistListMode(SubsonicArtistListMode mode)	{ _subsonicArtistListMode = mode; }
+		void setScrobbler(Scrobbler scrobbler)	{ _scrobbler = scrobbler; }
+		void setListenBrainzToken(const std::optional<UUID>& MBID)	{ _listenbrainzToken = MBID ? MBID->getAsString() : ""; }
+
+		// read
+		bool			isAdmin() const { return _type == UserType::ADMIN; }
+		bool			isDemo() const { return _type == UserType::DEMO; }
+		UserType		getType() const { return _type; }
+		bool			getSubsonicTranscodeEnable() const { return _subsonicTranscodeEnable; }
+		AudioFormat		getSubsonicTranscodeFormat() const { return _subsonicTranscodeFormat; }
+		Bitrate			getSubsonicTranscodeBitrate() const { return _subsonicTranscodeBitrate; }
+		std::size_t		getCurPlayingTrackPos() const { return _curPlayingTrackPos; }
+		bool			isRepeatAllSet() const { return _repeatAll; }
+		bool			isRadioSet() const { return _radio; }
+		UITheme			getUITheme() const { return _uiTheme; }
+		SubsonicArtistListMode	getSubsonicArtistListMode() const { return _subsonicArtistListMode; }
+		Scrobbler				getScrobbler() const { return _scrobbler; }
+		std::optional<UUID>		getListenBrainzToken() const	{ return UUID::fromString(_listenbrainzToken); }
+
+		ObjectPtr<TrackList>	getQueuedTrackList(Session& session) const;
+
+		void			starArtist(ObjectPtr<Artist> artist);
+		void			unstarArtist(ObjectPtr<Artist> artist);
+		bool			hasStarredArtist(ObjectPtr<Artist> artist) const;
+
+		void			starRelease(ObjectPtr<Release> release);
+		void			unstarRelease(ObjectPtr<Release> release);
+		bool			hasStarredRelease(ObjectPtr<Release> release) const;
+
+		// Stars
+		void			starTrack(ObjectPtr<Track> track);
+		void			unstarTrack(ObjectPtr<Track> track);
+		bool			hasStarredTrack(ObjectPtr<Track> track) const;
+
+		template<class Action>
+		void persist(Action& a)
+		{
+			Wt::Dbo::field(a, _type, "type");
+			Wt::Dbo::field(a, _loginName, "login_name");
+			Wt::Dbo::field(a, _passwordSalt, "password_salt");
+			Wt::Dbo::field(a, _passwordHash, "password_hash");
+			Wt::Dbo::field(a, _lastLogin, "last_login");
+			Wt::Dbo::field(a, _subsonicTranscodeEnable, "subsonic_transcode_enable");
+			Wt::Dbo::field(a, _subsonicTranscodeFormat, "subsonic_transcode_format");
+			Wt::Dbo::field(a, _subsonicTranscodeBitrate, "subsonic_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, _listenbrainzToken, "listenbrainz_token");
+
+			// UI settings
+			Wt::Dbo::field(a, _curPlayingTrackPos, "cur_playing_track_pos");
+			Wt::Dbo::field(a, _repeatAll, "repeat_all");
+			Wt::Dbo::field(a, _radio, "radio");
+
+			Wt::Dbo::hasMany(a, _tracklists, Wt::Dbo::ManyToOne, "user");
+			Wt::Dbo::hasMany(a, _starredArtists, Wt::Dbo::ManyToMany, "user_artist_starred", "", Wt::Dbo::OnDeleteCascade);
+			Wt::Dbo::hasMany(a, _starredReleases, Wt::Dbo::ManyToMany, "user_release_starred", "", Wt::Dbo::OnDeleteCascade);
+			Wt::Dbo::hasMany(a, _starredTracks, Wt::Dbo::ManyToMany, "user_track_starred", "", Wt::Dbo::OnDeleteCascade);
+			Wt::Dbo::hasMany(a, _authTokens, Wt::Dbo::ManyToOne, "user");
+		}
+
+	private:
+
+		std::string	_loginName;
+		std::string	_passwordSalt;
+		std::string	_passwordHash;
+		Wt::WDateTime	_lastLogin;
+		UITheme		_uiTheme {defaultUITheme};
+		Scrobbler	_scrobbler {defaultScrobbler};
+		std::string	_listenbrainzToken; // Musicbrainz Identifier
+
+		// Admin defined settings
+		UserType		_type {UserType::REGULAR};
+
+		// User defined settings
+		SubsonicArtistListMode	_subsonicArtistListMode {defaultSubsonicArtistListMode};
+		bool			_subsonicTranscodeEnable {defaultSubsonicTranscodeEnable};
+		AudioFormat		_subsonicTranscodeFormat {defaultSubsonicTranscodeFormat};
+		int				_subsonicTranscodeBitrate {defaultSubsonicTranscodeBitrate};
+
+		// User's dynamic data (UI)
+		int		_curPlayingTrackPos {}; // Current track position in queue
+		bool		_repeatAll {};
+		bool		_radio {};
+
+		Wt::Dbo::collection<Wt::Dbo::ptr<TrackList>> _tracklists;
+		Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> _starredArtists;
+		Wt::Dbo::collection<Wt::Dbo::ptr<Release>> _starredReleases;
+		Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _starredTracks;
+		Wt::Dbo::collection<Wt::Dbo::ptr<AuthToken>> _authTokens;
+
+};
+
+} // namespace Databas'
+

src/libs/services/database/test/Artist.cpp

@@ -0,0 +1,368 @@
+/*
+ * 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 "Common.hpp"
+
+using namespace Database;
+
+TEST_F(DatabaseFixture, SingleArtist)
+{
+	{
+		auto transaction {session.createSharedTransaction()};
+		EXPECT_FALSE(Artist::exists(session, 35));
+		EXPECT_FALSE(Artist::exists(session, 0));
+		EXPECT_FALSE(Artist::exists(session, 1));
+	}
+
+	ScopedArtist artist {session, "MyArtist"};
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_TRUE(artist.get());
+		EXPECT_FALSE(!artist.get());
+		EXPECT_EQ(artist.get()->getId(), artist.getId());
+
+		EXPECT_TRUE(Artist::exists(session, artist.getId()));
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		auto artists {Artist::getAll(session, Artist::SortMethod::ByName)};
+		ASSERT_EQ(artists.size(), 1);
+		EXPECT_EQ(artists.front()->getId(), artist.getId());
+
+		artists = Artist::getAllOrphans(session);
+		ASSERT_EQ(artists.size(), 1);
+		EXPECT_EQ(artists.front()->getId(), artist.getId());
+	}
+}
+
+TEST_F(DatabaseFixture, SingleTrackSingleArtist)
+{
+	ScopedTrack track {session, "MyTrack"};
+	ScopedArtist artist {session, "MyArtist"};
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+		EXPECT_TRUE(Artist::getAllOrphans(session).empty());
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		auto artists {track->getArtists({TrackArtistLinkType::Artist})};
+		ASSERT_EQ(artists.size(), 1);
+		EXPECT_EQ(artists.front()->getId(), artist.getId());
+
+		EXPECT_EQ(artist->getReleaseCount(), 0);
+
+		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);
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		auto tracks {artist->getTracks()};
+		ASSERT_EQ(tracks.size(), 1);
+		EXPECT_EQ(tracks.front()->getId(), track.getId());
+
+		EXPECT_TRUE(artist->getTracks(TrackArtistLinkType::ReleaseArtist).empty());
+		EXPECT_EQ(artist->getTracks(TrackArtistLinkType::Artist).size(), 1);
+	}
+}
+
+TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiRoles)
+{
+	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);
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+		EXPECT_TRUE(Artist::getAllOrphans(session).empty());
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+		bool hasMore{};
+		EXPECT_EQ(Artist::getByFilter(session, {}, {}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, hasMore).size(), 1);
+		EXPECT_EQ(Artist::getByFilter(session, {}, {}, TrackArtistLinkType::Artist, Artist::SortMethod::ByName, std::nullopt, hasMore).size(), 1);
+		EXPECT_EQ(Artist::getByFilter(session, {}, {}, TrackArtistLinkType::ReleaseArtist, Artist::SortMethod::ByName, std::nullopt, hasMore).size(), 1);
+		EXPECT_EQ(Artist::getByFilter(session, {}, {}, TrackArtistLinkType::Writer, Artist::SortMethod::ByName, std::nullopt, hasMore).size(), 1);
+		EXPECT_TRUE(Artist::getByFilter(session, {}, {}, TrackArtistLinkType::Composer, Artist::SortMethod::ByName, std::nullopt, hasMore).empty());
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		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());
+
+		EXPECT_EQ(track->getArtistLinks().size(), 3);
+
+		EXPECT_EQ(artist->getTracks().size(), 1);
+		EXPECT_EQ(artist->getTracks({TrackArtistLinkType::ReleaseArtist}).size(), 1);
+		EXPECT_EQ(artist->getTracks({TrackArtistLinkType::Artist}).size(), 1);
+		EXPECT_EQ(artist->getTracks({TrackArtistLinkType::Writer}).size(), 1);
+	}
+}
+
+TEST_F(DatabaseFixture,SingleTrackMultiArtists)
+{
+	ScopedTrack track {session, "track"};
+	ScopedArtist artist1 {session, "artist1"};
+	ScopedArtist artist2 {session, "artist2"};
+	ASSERT_NE(artist1.getId(), artist2.getId());
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		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::getAllOrphans(session).empty());
+	}
+
+	{
+		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()));
+
+		EXPECT_EQ(track->getArtists({}).size(), 2);
+		EXPECT_EQ(track->getArtists({TrackArtistLinkType::Artist}).size(), 2);
+		EXPECT_TRUE(track->getArtists({TrackArtistLinkType::ReleaseArtist}).empty());
+		EXPECT_EQ(Artist::getAll(session, Artist::SortMethod::ByName).size(), 2);
+		EXPECT_EQ(Artist::getAllIds(session).size(), 2);
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		EXPECT_EQ(artist1->getTracks().front(), track.get());
+		EXPECT_EQ(artist2->getTracks().front(), track.get());
+
+		EXPECT_TRUE(artist1->getTracks(TrackArtistLinkType::ReleaseArtist).empty());
+		EXPECT_EQ(artist1->getTracks(TrackArtistLinkType::Artist).size(), 1);
+		EXPECT_TRUE(artist2->getTracks(TrackArtistLinkType::ReleaseArtist).empty());
+		EXPECT_EQ(artist2->getTracks(TrackArtistLinkType::Artist).size(), 1);
+	}
+}
+
+TEST_F(DatabaseFixture, SingleArtistSearchByName)
+{
+	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.createSharedTransaction()};
+
+		bool more {};
+		EXPECT_TRUE(Artist::getByFilter(session, {}, {"N"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more).empty());
+
+		const auto artistsByAAA {Artist::Artist::getByFilter(session, {}, {"A"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
+		ASSERT_EQ(artistsByAAA.size(), 1);
+		EXPECT_EQ(artistsByAAA.front()->getId(), artist.getId());
+
+		const auto artistsByZZZ {Artist::Artist::getByFilter(session, {}, {"Z"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
+		ASSERT_EQ(artistsByZZZ.size(), 1);
+		EXPECT_EQ(artistsByZZZ.front()->getId(), artist.getId());
+
+		EXPECT_TRUE(Artist::getByName(session, "NNN").empty());
+	}
+}
+
+TEST_F(DatabaseFixture, MultipleArtistsSearchByNameEscaped)
+{
+	ScopedArtist artist1 {session, "MyArtist%"};
+	ScopedArtist artist2 {session, "%MyArtist"};
+	ScopedArtist artist3 {session, "%_MyArtist"};
+
+	ScopedArtist artist4 {session, "MyArtist%foo"};
+	ScopedArtist artist5 {session, "foo%MyArtist"};
+	ScopedArtist artist6 {session, "%AMyArtist"};
+
+	{
+		auto transaction {session.createSharedTransaction()};
+		{
+			const auto artists {Artist::getByName(session, "MyArtist%")};
+			ASSERT_TRUE(artists.size() == 1);
+			EXPECT_EQ(artists.front()->getId(), artist1.getId());
+			EXPECT_TRUE(Artist::getByName(session, "MyArtistFoo").empty());
+		}
+		{
+			const auto artists {Artist::getByName(session, "%MyArtist")};
+			ASSERT_TRUE(artists.size() == 1);
+			EXPECT_EQ(artists.front()->getId(), artist2.getId());
+			EXPECT_TRUE(Artist::getByName(session, "FooMyArtist").empty());
+		}
+		{
+			const auto artists {Artist::getByName(session, "%_MyArtist")};
+			ASSERT_TRUE(artists.size() == 1);
+			ASSERT_EQ(artists.front()->getId(), artist3.getId());
+			EXPECT_TRUE(Artist::getByName(session, "%CMyArtist").empty());
+		}
+	}
+
+	// get by filter only works with tracks links...
+	ScopedTrack track {session, "MyTrack"}; // filters does not work on orphans
+
+	{
+		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(), artist3.get(), TrackArtistLinkType::Artist);
+		TrackArtistLink::create(session, track.get(), artist4.get(), TrackArtistLinkType::Artist);
+		TrackArtistLink::create(session, track.get(), artist5.get(), TrackArtistLinkType::Artist);
+		TrackArtistLink::create(session, track.get(), artist6.get(), TrackArtistLinkType::Artist);
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+		bool more;
+		{
+			const auto artists {Artist::getByFilter(session, {}, {"MyArtist"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
+			EXPECT_EQ(artists.size(), 6);
+		}
+
+		{
+			const auto artists {Artist::getByFilter(session, {}, {"MyArtist%"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
+			ASSERT_EQ(artists.size(), 2);
+			EXPECT_EQ(artists[0]->getId(), artist1.getId());
+			EXPECT_EQ(artists[1]->getId(), artist4.getId());
+		}
+
+		{
+			const auto artists {Artist::getByFilter(session, {}, {"%MyArtist"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
+			ASSERT_EQ(artists.size(), 2);
+			EXPECT_EQ(artists[0]->getId(), artist2.getId());
+			EXPECT_EQ(artists[1]->getId(), artist5.getId());
+		}
+
+		{
+			const auto artists {Artist::getByFilter(session, {}, {"_MyArtist"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
+			ASSERT_EQ(artists.size(), 1);
+			EXPECT_EQ(artists[0]->getId(), artist3.getId());
+		}
+	}
+}
+
+TEST_F(DatabaseFixture, MultiArtistsSortMethod)
+{
+	ScopedArtist artistA {session, "artistA"};
+	ScopedArtist artistB {session, "artistB"};
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		artistA.get().modify()->setSortName("sortNameB");
+		artistB.get().modify()->setSortName("sortNameA");
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		auto allArtistsByName {Artist::getAll(session, Artist::SortMethod::ByName)};
+		auto allArtistsBySortName {Artist::getAll(session, Artist::SortMethod::BySortName)};
+
+		ASSERT_EQ(allArtistsByName.size(), 2);
+		EXPECT_EQ(allArtistsByName.front()->getId(), artistA.getId());
+		EXPECT_EQ(allArtistsByName.back()->getId(), artistB.getId());
+
+		ASSERT_EQ(allArtistsBySortName.size(), 2);
+		EXPECT_EQ(allArtistsBySortName.front()->getId(), artistB.getId());
+		EXPECT_EQ(allArtistsBySortName.back()->getId(), artistA.getId());
+	}
+}
+
+TEST_F(DatabaseFixture, SingleArtistNonReleaseTracks)
+{
+	ScopedArtist artist {session, "artist"};
+	ScopedTrack track1 {session, "MyTrack1"};
+	ScopedTrack track2 {session, "MyTrack2"};
+	ScopedRelease release{session, "MyRelease"};
+
+	{
+		auto transaction {session.createSharedTransaction()};
+		EXPECT_FALSE(artist->hasNonReleaseTracks(std::nullopt));
+
+		bool moreResults;
+		const auto tracks {artist->getNonReleaseTracks(std::nullopt, std::nullopt, moreResults )};
+		EXPECT_EQ(tracks.size(), 0);
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		TrackArtistLink::create(session, track1.get(), artist.get(), TrackArtistLinkType::Artist);
+		TrackArtistLink::create(session, track2.get(), artist.get(), TrackArtistLinkType::Artist);
+
+		track1.get().modify()->setRelease(release.get());
+	}
+
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		bool moreResults;
+		const auto tracks {artist->getNonReleaseTracks(std::nullopt, std::nullopt, moreResults )};
+		EXPECT_TRUE(artist->hasNonReleaseTracks(std::nullopt));
+		EXPECT_FALSE(moreResults);
+		ASSERT_EQ(tracks.size(), 1);
+		EXPECT_EQ(tracks.front()->getId(), track2.getId());
+	}
+}

src/libs/services/database/test/CMakeLists.txt

@@ -0,0 +1,18 @@
+
+add_executable(test-database
+	Artist.cpp
+	Cluster.cpp
+	DatabaseTest.cpp
+	Release.cpp
+	Track.cpp
+	)
+
+target_link_libraries(test-database PRIVATE
+	lmsdatabase
+	GTest::GTest
+	)
+
+if (NOT CMAKE_CROSSCOMPILING)
+	gtest_discover_tests(test-database)
+endif()
+

src/libs/services/database/test/Common.hpp

@@ -0,0 +1,183 @@
+/*
+ * 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 <filesystem>
+#include <memory>
+
+#include <gtest/gtest.h>
+
+#include "database/Artist.hpp"
+#include "database/Cluster.hpp"
+#include "database/Db.hpp"
+#include "database/Release.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "database/TrackArtistLink.hpp"
+#include "database/TrackBookmark.hpp"
+#include "database/TrackList.hpp"
+#include "database/Types.hpp"
+#include "database/User.hpp"
+
+template <typename T>
+class ScopedEntity
+{
+	public:
+		using IdType = typename T::IdType;
+
+		template <typename... Args>
+		ScopedEntity(Database::Session& session, Args&& ...args)
+			: _session {session}
+		{
+			auto transaction {_session.createUniqueTransaction()};
+
+			auto entity {T::create(_session, std::forward<Args>(args)...)};
+			EXPECT_TRUE(entity);
+			_id = entity->getId();
+		}
+
+		~ScopedEntity()
+		{
+			auto transaction {_session.createUniqueTransaction()};
+
+			auto entity {T::getById(_session, _id)};
+			entity.remove();
+		}
+
+		ScopedEntity(const ScopedEntity&) = delete;
+		ScopedEntity(ScopedEntity&&) = delete;
+		ScopedEntity& operator=(const ScopedEntity&) = delete;
+		ScopedEntity& operator=(ScopedEntity&&) = delete;
+
+		typename T::pointer lockAndGet()
+		{
+			auto transaction {_session.createSharedTransaction()};
+			return get();
+		}
+
+		typename T::pointer get()
+		{
+			_session.checkSharedLocked();
+
+			auto entity {T::getById(_session, _id)};
+			EXPECT_TRUE(entity);
+			return entity;
+		}
+
+		typename T::pointer operator->()
+		{
+			return get();
+		}
+
+		IdType getId() const { return _id; }
+
+	private:
+		Database::Session& _session;
+		IdType _id {};
+};
+
+using ScopedArtist = ScopedEntity<Database::Artist>;
+using ScopedCluster = ScopedEntity<Database::Cluster>;
+using ScopedClusterType = ScopedEntity<Database::ClusterType>;
+using ScopedRelease = ScopedEntity<Database::Release>;
+using ScopedTrack = ScopedEntity<Database::Track>;
+using ScopedTrackBookmark = ScopedEntity<Database::TrackBookmark>;
+using ScopedTrackList = ScopedEntity<Database::TrackList>;
+using ScopedUser = ScopedEntity<Database::User>;
+
+class ScopedFileDeleter final
+{
+	public:
+		ScopedFileDeleter(const std::filesystem::path& path) : _path {path} {}
+		~ScopedFileDeleter() { std::filesystem::remove(_path); }
+
+		ScopedFileDeleter(const ScopedFileDeleter&) = delete;
+		ScopedFileDeleter(ScopedFileDeleter&&) = delete;
+		ScopedFileDeleter operator=(const ScopedFileDeleter&) = delete;
+		ScopedFileDeleter operator=(ScopedFileDeleter&&) = delete;
+
+	private:
+		const std::filesystem::path _path;
+};
+
+class TmpDatabase final
+{
+	public:
+		Database::Db& getDb() { return _db; }
+
+	private:
+		const std::filesystem::path _tmpFile {std::tmpnam(nullptr)};
+		ScopedFileDeleter fileDeleter {_tmpFile};
+		Database::Db _db {_tmpFile};
+};
+
+class DatabaseFixture : public ::testing::Test
+{
+public:
+	~DatabaseFixture()
+	{
+		testDatabaseEmpty();
+	}
+
+public:
+    static void SetUpTestCase()
+	{
+		_tmpDb = std::make_unique<TmpDatabase>();
+		{
+			Database::Session s {_tmpDb->getDb()};
+			s.prepareTables();
+			s.optimize();
+
+			// remove default created entries
+			{
+				auto transaction {s.createUniqueTransaction()};
+				auto clusterTypes {Database::ClusterType::getAll(s)};
+				for (auto& clusterType : clusterTypes)
+					clusterType.remove();
+			}
+		}
+    }
+
+    static void TearDownTestCase()
+	{
+		_tmpDb.reset();
+    }
+
+private:
+	void testDatabaseEmpty()
+	{
+		auto uniqueTransaction {session.createUniqueTransaction()};
+
+		EXPECT_TRUE(Database::Artist::getAll(session, Database::Artist::SortMethod::ByName).empty());
+		EXPECT_TRUE(Database::Cluster::getAll(session).empty());
+		EXPECT_TRUE(Database::ClusterType::getAll(session).empty());
+		EXPECT_TRUE(Database::Release::getAll(session).empty());
+		EXPECT_TRUE(Database::Track::getAll(session).empty());
+		EXPECT_TRUE(Database::TrackBookmark::getAll(session).empty());
+		EXPECT_TRUE(Database::TrackList::getAll(session).empty());
+		EXPECT_TRUE(Database::User::getAll(session).empty());
+	}
+
+	static inline std::unique_ptr<TmpDatabase> _tmpDb {};
+
+public:
+	Database::Session session {_tmpDb->getDb()};
+};
+

src/libs/services/database/test/DatabaseTest.cpp

@@ -0,0 +1,410 @@
+/*
+ * 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/>.
+ */
+
+#include <list>
+
+#include "Common.hpp"
+
+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"};
+
+	for (std::size_t i {}; i < nbTracks; ++i)
+	{
+		tracks.emplace_back(session, "MyTrack" + std::to_string(i));
+
+		auto transaction {session.createUniqueTransaction()};
+
+		TrackArtistLink::create(session, tracks.back().get(), artist.get(), TrackArtistLinkType::Artist);
+		tracks.back().get().modify()->setRelease(release.get());
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+		EXPECT_TRUE(Release::getAllOrphans(session).empty());
+		EXPECT_TRUE(Artist::getAllOrphans(session).empty());
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_EQ(artist->getReleaseCount(), 1);
+		ASSERT_EQ(artist->getReleases().size(), 1);
+		EXPECT_EQ(artist->getReleases().front()->getId(), release.getId());
+
+		EXPECT_EQ(release->getTracks().size(), nbTracks);
+	}
+}
+
+TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtist)
+{
+	ScopedTrack track {session, "MyTrack"};
+	ScopedRelease release {session, "MyRelease"};
+	ScopedArtist artist {session, "MyArtist"};
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		auto trackArtistLink {TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist)};
+		track.get().modify()->setRelease(release.get());
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		auto releases {artist->getReleases()};
+		ASSERT_EQ(releases.size(), 1);
+		EXPECT_EQ(releases.front()->getId(), release.getId());
+
+		EXPECT_EQ(artist->getReleaseCount(), 1);
+
+		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::getAll(session).empty());
+		EXPECT_TRUE(User::getAllIds(session).empty());
+	}
+
+	ScopedUser user {session, "MyUser"};
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_EQ(user->getQueuedTrackList(session)->getCount(), 0);
+		EXPECT_EQ(User::getAll(session).size(), 1);
+		EXPECT_EQ(User::getAllIds(session).size(), 1);
+	}
+}
+
+TEST_F(DatabaseFixture, SingleStarredArtist)
+{
+	ScopedArtist artist {session, "MyArtist"};
+	ScopedTrack track {session, "MyTrack"};
+	ScopedUser user {session, "MyUser"};
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		EXPECT_FALSE(user->hasStarredArtist(artist.get()));
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		auto trackArtistLink {TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist)};
+		user.get().modify()->starArtist(artist.get());
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_TRUE(user->hasStarredArtist(artist.get()));
+
+		bool hasMore {};
+		auto artists {Artist::getStarred(session, user.get(), {}, std::nullopt, Artist::SortMethod::BySortName, std::nullopt, hasMore)};
+		ASSERT_EQ(artists.size(), 1);
+		EXPECT_EQ(artists.front()->getId(), artist.getId());
+		EXPECT_FALSE(hasMore);
+	}
+}
+
+TEST_F(DatabaseFixture, SingleStarredRelease)
+{
+	ScopedRelease release {session, "MyRelease"};
+	ScopedTrack track {session, "MyTrack"};
+	ScopedUser user {session, "MyUser"};
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_FALSE(user->hasStarredRelease(release.get()));
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		track.get().modify()->setRelease(release.get());
+		user.get().modify()->starRelease(release.get());
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_TRUE(user->hasStarredRelease(release.get()));
+
+		bool hasMore {};
+		auto releases {Release::getStarred(session, user.get(), {}, std::nullopt, hasMore)};
+		ASSERT_EQ(releases.size(), 1);
+		EXPECT_EQ(releases.front()->getId(), release.getId());
+		EXPECT_FALSE(hasMore);
+	}
+}
+
+TEST_F(DatabaseFixture, SingleStarredTrack)
+{
+	ScopedTrack track {session, "MyTrack"};
+	ScopedUser user {session, "MyUser"};
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		EXPECT_FALSE(user->hasStarredTrack(track.get()));
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		user.get().modify()->starTrack(track.get());
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		EXPECT_TRUE(user->hasStarredTrack(track.get()));
+
+		bool hasMore {};
+		auto tracks {Track::getStarred(session, user.get(), {}, std::nullopt, hasMore)};
+		ASSERT_EQ(tracks.size(), 1);
+		EXPECT_EQ(tracks.front()->getId(), track.getId());
+		EXPECT_FALSE(hasMore);
+	}
+}
+
+TEST_F(DatabaseFixture, SingleTrackList)
+{
+	ScopedUser user {session, "MyUser"};
+	ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		auto trackLists {TrackList::getAll(session, user.get(), TrackList::Type::Playlist)};
+		ASSERT_EQ(trackLists.size(), 1);
+		EXPECT_EQ(trackLists.front()->getId(), trackList.getId());
+	}
+}
+
+TEST_F(DatabaseFixture, SingleTrackListMultipleTrack)
+{
+	ScopedUser user {session, "MyUser"};
+	ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
+	std::list<ScopedTrack> tracks;
+
+	for (std::size_t i {}; i < 10; ++i)
+	{
+		tracks.emplace_back(session, "MyTrack" + std::to_string(i));
+
+		auto transaction {session.createUniqueTransaction()};
+		TrackListEntry::create(session, tracks.back().get(), trackList.get());
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		ASSERT_EQ(trackList->getCount(), tracks.size());
+		const auto trackIds {trackList->getTrackIds()};
+		for (auto trackId : trackIds)
+			EXPECT_TRUE(std::any_of(std::cbegin(tracks), std::cend(tracks), [trackId](const ScopedTrack& track) { return track.getId() == trackId; }));
+	}
+}
+
+TEST_F(DatabaseFixture, SingleTrackListMultipleTrackDateTime)
+{
+	ScopedUser user {session, "MyUser"};
+	ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
+	ScopedTrack track1 {session, "MyTrack1"};
+	ScopedTrack track2 {session, "MyTrack2"};
+	ScopedTrack track3 {session, "MyTrack3"};
+
+	{
+		Wt::WDateTime now {Wt::WDateTime::currentDateTime()};
+		auto transaction {session.createUniqueTransaction()};
+		TrackListEntry::create(session, track1.get(), trackList.get(), now);
+		TrackListEntry::create(session, track2.get(), trackList.get(), now.addSecs(-1));
+		TrackListEntry::create(session, track3.get(), trackList.get(), now.addSecs(1));
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		bool moreResults;
+		const auto tracks {trackList.get()->getTracksReverse({}, std::nullopt, moreResults)};
+		ASSERT_EQ(tracks.size(), 3);
+		EXPECT_EQ(tracks.front()->getId(), track3.getId());
+		EXPECT_EQ(tracks.back()->getId(), track2.getId());
+	}
+}
+
+TEST_F(DatabaseFixture, SingleTrackListMultipleTrackRecentlyPlayed)
+{
+	ScopedUser user {session, "MyUser"};
+	ScopedTrackList trackList {session, "MyTrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
+	ScopedTrack track1 {session, "MyTrack1"};
+	ScopedTrack track2 {session, "MyTrack1"};
+	ScopedArtist artist1 {session, "MyArtist1"};
+	ScopedArtist artist2 {session, "MyArtist2"};
+	ScopedRelease release1 {session, "MyRelease1"};
+	ScopedRelease release2 {session, "MyRelease2"};
+
+	const Wt::WDateTime now {Wt::WDateTime::currentDateTime()};
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		track1.get().modify()->setRelease(release1.get());
+		track2.get().modify()->setRelease(release2.get());
+		TrackArtistLink::create(session, track1.get(), artist1.get(), TrackArtistLinkType::Artist);
+		TrackArtistLink::create(session, track2.get(), artist2.get(), TrackArtistLinkType::Artist);
+	}
+	{
+
+		auto transaction {session.createSharedTransaction()};
+
+		bool moreResults {};
+		EXPECT_TRUE(trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults).empty());
+		EXPECT_TRUE(trackList->getReleasesReverse({}, std::nullopt, moreResults).empty());
+		EXPECT_TRUE(trackList->getTracksReverse({}, std::nullopt, moreResults).empty());
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		TrackListEntry::create(session, track1.get(), trackList.get(), now);
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		bool moreResults {};
+		const auto artists {trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults)};
+		ASSERT_EQ(artists.size(), 1);
+		EXPECT_EQ(artists.front()->getId(), artist1.getId());
+
+		const auto releases {trackList->getReleasesReverse({}, std::nullopt, moreResults)};
+		ASSERT_EQ(releases.size(), 1);
+		EXPECT_EQ(releases.front()->getId(), release1.getId());
+
+		const auto tracks {trackList->getTracksReverse({}, std::nullopt, moreResults)};
+		EXPECT_EQ(tracks.size(), 1);
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		TrackListEntry::create(session, track2.get(), trackList.get(), now.addSecs(1));
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		bool moreResults {};
+		const auto artists {trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults)};
+		ASSERT_EQ(artists.size(), 2);
+		EXPECT_EQ(artists[0]->getId(), artist2.getId());
+		EXPECT_EQ(artists[1]->getId(), artist1.getId());
+
+		const auto releases {trackList->getReleasesReverse({}, std::nullopt, moreResults)};
+		ASSERT_EQ(releases.size(), 2);
+		EXPECT_EQ(releases[0]->getId(), release2.getId());
+		EXPECT_EQ(releases[1]->getId(), release1.getId());
+
+		const auto tracks {trackList->getTracksReverse({}, std::nullopt, moreResults)};
+		ASSERT_EQ(tracks.size(), 2);
+		EXPECT_EQ(tracks[0]->getId(), track2.getId());
+		EXPECT_EQ(tracks[1]->getId(), track1.getId());
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		TrackListEntry::create(session, track1.get(), trackList.get(), now.addSecs(2));
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		bool moreResults {};
+		const auto artists {trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults)};
+		ASSERT_EQ(artists.size(), 2);
+		EXPECT_EQ(artists[0]->getId(), artist1.getId());
+		EXPECT_EQ(artists[1]->getId(), artist2.getId());
+
+		const auto releases {trackList->getReleasesReverse({}, std::nullopt, moreResults)};
+		ASSERT_EQ(releases.size(), 2);
+		EXPECT_EQ(releases[0]->getId(), release1.getId());
+		EXPECT_EQ(releases[1]->getId(), release2.getId());
+
+		const auto tracks {trackList->getTracksReverse({}, std::nullopt, moreResults)};
+		ASSERT_EQ(tracks.size(), 2);
+		EXPECT_EQ(tracks[0]->getId(), track1.getId());
+		EXPECT_EQ(tracks[1]->getId(), track2.getId());
+	}
+}
+
+TEST_F(DatabaseFixture, SingleTrackSingleUserSingleBookmark)
+{
+	ScopedTrack track {session, "MyTrack"};
+	ScopedUser user {session, "MyUser"};
+	ScopedTrackBookmark bookmark {session, user.lockAndGet(), track.lockAndGet()};
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		bookmark.get().modify()->setComment("MyComment");
+		bookmark.get().modify()->setOffset(std::chrono::milliseconds {5});
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_EQ(TrackBookmark::getAll(session).size(), 1);
+
+		const auto bookmarks {TrackBookmark::getByUser(session, user.get())};
+		ASSERT_EQ(bookmarks.size(), 1);
+		EXPECT_EQ(bookmarks.back(), bookmark.get());
+	}
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		auto userBookmark {TrackBookmark::getByUser(session, user.get(), track.get())};
+		ASSERT_TRUE(userBookmark);
+		EXPECT_EQ(userBookmark, bookmark.get());
+
+		EXPECT_EQ(userBookmark->getOffset(), std::chrono::milliseconds {5});
+		EXPECT_EQ(userBookmark->getComment(), "MyComment");
+	}
+}
+
+int main(int argc, char **argv)
+{
+	::testing::InitGoogleTest(&argc, argv);
+	return RUN_ALL_TESTS();
+}

src/libs/services/database/test/Release.cpp

@@ -0,0 +1,363 @@
+/*
+ * 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 "Common.hpp"
+
+using namespace Database;
+
+TEST_F(DatabaseFixture, SingleRelease)
+{
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_FALSE(Release::exists(session, 0));
+		EXPECT_FALSE(Release::exists(session, 1));
+	}
+
+	ScopedRelease release {session, "MyRelease"};
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_TRUE(Release::exists(session, release.getId()));
+
+		auto releases {Release::getAllOrphans(session)};
+		ASSERT_EQ(releases.size(), 1);
+		EXPECT_EQ(releases.front()->getId(), release.getId());
+
+		releases = Release::getAll(session);
+		ASSERT_EQ(releases.size(), 1);
+		EXPECT_EQ(releases.front()->getId(), release.getId());
+		EXPECT_EQ(release->getDuration(), std::chrono::seconds {0});
+	}
+}
+
+TEST_F(DatabaseFixture, SingleTrackSingleRelease)
+{
+	ScopedRelease release {session, "MyRelease"};
+
+	{
+		ScopedTrack track {session, "MyTrack"};
+		{
+			auto transaction {session.createUniqueTransaction()};
+
+			track.get().modify()->setRelease(release.get());
+			track.get().modify()->setName("MyTrackName");
+			release.get().modify()->setName("MyReleaseName");
+		}
+
+		{
+			auto transaction {session.createSharedTransaction()};
+			EXPECT_TRUE(Release::getAllOrphans(session).empty());
+
+			EXPECT_EQ(release->getTracksCount(), 1);
+			ASSERT_EQ(release->getTracks().size(), 1);
+			EXPECT_EQ(release->getTracks().front()->getId(), track.getId());
+		}
+
+		{
+			auto transaction {session.createUniqueTransaction()};
+
+			ASSERT_TRUE(track->getRelease());
+			EXPECT_EQ(track->getRelease()->getId(), release.getId());
+		}
+
+		{
+			auto transaction {session.createUniqueTransaction()};
+			auto tracks {Track::getByNameAndReleaseName(session, "MyTrackName", "MyReleaseName")};
+			ASSERT_EQ(tracks.size(), 1);
+			EXPECT_EQ(tracks.front()->getId(), track.getId());
+		}
+		{
+			auto transaction {session.createUniqueTransaction()};
+			auto tracks {Track::getByNameAndReleaseName(session, "MyTrackName", "MyReleaseFoo")};
+			EXPECT_EQ(tracks.size(), 0);
+		}
+		{
+			auto transaction {session.createUniqueTransaction()};
+			auto tracks {Track::getByNameAndReleaseName(session, "MyTrackFoo", "MyReleaseName")};
+			EXPECT_EQ(tracks.size(), 0);
+		}
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		EXPECT_TRUE(release->getTracks().empty());
+
+		auto releases {Release::getAllOrphans(session)};
+		ASSERT_EQ(releases.size(), 1);
+		EXPECT_EQ(releases.front()->getId(), 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"};
+
+	// 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()};
+
+		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()};
+
+		bool more;
+		{
+			const auto releases {Release::getByFilter(session, {}, {"Release"}, std::nullopt, more)};
+			EXPECT_EQ(releases.size(), 6);
+		}
+
+		{
+			const auto releases {Release::getByFilter(session, {}, {"MyRelease"}, std::nullopt, more)};
+			EXPECT_EQ(releases.size(), 5);
+			EXPECT_TRUE(std::none_of(std::cbegin(releases), std::cend(releases), [&](const Release::pointer& release) { return release->getId() == release6.getId(); }));
+		}
+		{
+			const auto releases {Release::getByFilter(session, {}, {"MyRelease%"}, std::nullopt, more)};
+			ASSERT_EQ(releases.size(), 2);
+			EXPECT_EQ(releases[0]->getId(), release2.getId());
+			EXPECT_EQ(releases[1]->getId(), release4.getId());
+		}
+		{
+			const auto releases {Release::getByFilter(session, {}, {"%MyRelease"}, std::nullopt, more)};
+			ASSERT_EQ(releases.size(), 2);
+			EXPECT_EQ(releases[0]->getId(), release3.getId());
+			EXPECT_EQ(releases[1]->getId(), release5.getId());
+		}
+		{
+			const auto releases {Release::getByFilter(session, {}, {"Foo%MyRelease"}, std::nullopt, more)};
+			ASSERT_EQ(releases.size(), 1);
+			EXPECT_EQ(releases[0]->getId(), release5.getId());
+		}
+		{
+			const auto releases {Release::getByFilter(session, {}, {"MyRelease%Foo"}, std::nullopt, more)};
+			ASSERT_EQ(releases.size(), 1);
+			EXPECT_EQ(releases[0]->getId(), release4.getId());
+		}
+	}
+}
+
+TEST_F(DatabaseFixture, MultiTracksSingleReleaseTotalDiscTrack)
+{
+	ScopedRelease release1 {session, "MyRelease"};
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_FALSE(release1->getTotalTrack());
+		EXPECT_FALSE(release1->getTotalDisc());
+	}
+
+	ScopedTrack track1 {session, "MyTrack"};
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		track1.get().modify()->setRelease(release1.get());
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_FALSE(release1->getTotalTrack());
+		EXPECT_FALSE(release1->getTotalDisc());
+	}
+
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		track1.get().modify()->setTotalTrack(36);
+		track1.get().modify()->setTotalDisc(6);
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		ASSERT_TRUE(release1->getTotalTrack());
+		EXPECT_EQ(*release1->getTotalTrack(), 36);
+		ASSERT_TRUE(release1->getTotalDisc());
+		EXPECT_EQ(*release1->getTotalDisc(), 6);
+	}
+
+	ScopedTrack track2 {session, "MyTrack2"};
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		track2.get().modify()->setRelease(release1.get());
+		track2.get().modify()->setTotalTrack(37);
+		track2.get().modify()->setTotalDisc(67);
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		ASSERT_TRUE(release1->getTotalTrack());
+		EXPECT_EQ(*release1->getTotalTrack(), 37);
+		ASSERT_TRUE(release1->getTotalDisc());
+		EXPECT_EQ(*release1->getTotalDisc(), 67);
+	}
+
+	ScopedRelease release2 {session, "MyRelease2"};
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_FALSE(release2->getTotalTrack());
+		EXPECT_FALSE(release2->getTotalDisc());
+	}
+
+	ScopedTrack track3 {session, "MyTrack3"};
+	{
+		auto transaction {session.createUniqueTransaction()};
+
+		track3.get().modify()->setRelease(release2.get());
+		track3.get().modify()->setTotalTrack(7);
+		track3.get().modify()->setTotalDisc(5);
+	}
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		ASSERT_TRUE(release1->getTotalTrack());
+		EXPECT_EQ(*release1->getTotalTrack(), 37);
+		ASSERT_TRUE(release1->getTotalDisc());
+		EXPECT_EQ(*release1->getTotalDisc(), 67);
+		ASSERT_TRUE(release2->getTotalTrack());
+		EXPECT_EQ(*release2->getTotalTrack(), 7);
+		ASSERT_TRUE(release2->getTotalDisc());
+		EXPECT_EQ(*release2->getTotalDisc(), 5);
+	}
+}
+
+TEST_F(DatabaseFixture, MultiTracksSingleReleaseFirstTrack)
+{
+	ScopedRelease release1 {session, "MyRelease1"};
+	ScopedRelease release2 {session, "MyRelease2"};
+
+	ScopedTrack track1A {session, "MyTrack1A"};
+	ScopedTrack track1B {session, "MyTrack1B"};
+	ScopedTrack track2A {session, "MyTrack2A"};
+	ScopedTrack track2B {session, "MyTrack2B"};
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_FALSE(release1->getFirstTrack());
+		EXPECT_FALSE(release2->getFirstTrack());
+	}
+
+	{
+		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()->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);
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_TRUE(release1->getFirstTrack());
+		EXPECT_TRUE(release2->getFirstTrack());
+
+		EXPECT_EQ(release1->getFirstTrack()->getId(), track1A.getId());
+		EXPECT_EQ(release2->getFirstTrack()->getId(), 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}};
+
+	ScopedTrack track1A {session, "MyTrack1A"};
+	ScopedTrack track1B {session, "MyTrack1B"};
+	ScopedTrack track2A {session, "MyTrack2A"};
+	ScopedTrack track2B {session, "MyTrack2B"};
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		const auto releases {Release::getByYear(session, 0, 3000)};
+		EXPECT_EQ(releases.size(), 0);
+	}
+
+	{
+		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()->setDate(release1Date);
+		track1B.get().modify()->setDate(release1Date);
+		track1A.get().modify()->setOriginalDate(release1OriginalDate);
+		track1B.get().modify()->setOriginalDate(release1OriginalDate);
+
+		EXPECT_EQ(release1.get()->getReleaseYear(), release1Date.year());
+		EXPECT_EQ(release1.get()->getReleaseYear(true), release1OriginalDate.year());
+	}
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		auto releases {Release::getByYear(session, 1950, 2000)};
+		ASSERT_EQ(releases.size(), 1);
+		EXPECT_EQ(releases.front()->getId(), release1.getId());
+
+		releases = Release::getByYear(session, 1994, 1994);
+		ASSERT_EQ(releases.size(), 1);
+		EXPECT_EQ(releases.front()->getId(), release1.getId());
+
+		releases = Release::getByYear(session, 1993, 1993);
+		ASSERT_EQ(releases.size(), 0);
+	}
+}
+

src/libs/services/database/test/Track.cpp

@@ -0,0 +1,119 @@
+/*
+ * 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 "Common.hpp"
+
+#include <algorithm>
+
+using namespace Database;
+
+TEST_F(DatabaseFixture, SingleTrack)
+{
+	{
+		auto transaction {session.createSharedTransaction()};
+		EXPECT_EQ(Track::getCount(session), 0);
+		EXPECT_FALSE(Track::exists(session, 0));
+	}
+
+	ScopedTrack track {session, "MyTrackFile"};
+
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		EXPECT_EQ(Track::getAll(session).size(), 1);
+		EXPECT_EQ(Track::getCount(session), 1);
+		EXPECT_TRUE(Track::exists(session, track.getId()));
+		auto myTrack {Track::getById(session, track.getId())};
+		ASSERT_TRUE(myTrack);
+		EXPECT_EQ(myTrack->getId(), track.getId());
+	}
+}
+
+TEST_F(DatabaseFixture, MultipleTracksSearchByFilter)
+{
+	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.createSharedTransaction()};
+
+		bool more;
+		{
+			const auto tracks {Track::getByFilter(session, {}, {"Track"}, std::nullopt, more)};
+			EXPECT_EQ(tracks.size(), 6);
+		}
+		{
+			const auto tracks {Track::getByFilter(session, {}, {"MyTrack"}, std::nullopt, more)};
+			EXPECT_EQ(tracks.size(), 5);
+			EXPECT_TRUE(std::none_of(std::cbegin(tracks), std::cend(tracks), [&](const Track::pointer& track) { return track->getId() == track6.getId(); }));
+		}
+		{
+			const auto tracks {Track::getByFilter(session, {}, {"MyTrack%"}, std::nullopt, more)};
+			ASSERT_EQ(tracks.size(), 2);
+			EXPECT_EQ(tracks[0]->getId(), track2.getId());
+			EXPECT_EQ(tracks[1]->getId(), track3.getId());
+		}
+		{
+			const auto tracks {Track::getByFilter(session, {}, {"%MyTrack"}, std::nullopt, more)};
+			ASSERT_EQ(tracks.size(), 2);
+			EXPECT_EQ(tracks[0]->getId(), track4.getId());
+			EXPECT_EQ(tracks[1]->getId(), track5.getId());
+		}
+	}
+}
+
+TEST_F(DatabaseFixture, SingleTrackDate)
+{
+	ScopedTrack track {session, "MyTrack"};
+
+	{
+		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.createSharedTransaction()};
+		EXPECT_EQ(track->getYear(), 1995);
+		EXPECT_EQ(track->getOriginalYear(), 1994);
+	}
+}
+
+
+

src/libs/services/recommendation/CMakeLists.txt

@@ -0,0 +1,26 @@
+
+add_library(lmsrecommendation SHARED
+	impl/clusters/ClustersEngine.cpp
+	impl/features/FeaturesEngineCache.cpp
+	impl/features/FeaturesEngine.cpp
+	impl/features/FeaturesDefs.cpp
+	impl/Engine.cpp
+	)
+
+target_include_directories(lmsrecommendation INTERFACE
+	include
+	)
+
+target_include_directories(lmsrecommendation PRIVATE
+	impl
+	include
+	)
+
+target_link_libraries(lmsrecommendation PRIVATE
+	lmsdatabase
+	lmssom
+	std::filesystem
+	)
+
+install(TARGETS lmsrecommendation DESTINATION lib)
+

src/libs/services/recommendation/impl/ClustersEngineCreator.hpp

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2020 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>
+
+namespace Database
+{
+	class Db;
+}
+
+namespace Recommendation
+{
+	class IEngine;
+	std::unique_ptr<IEngine> createClustersEngine(Database::Db& db);
+}
+

src/libs/services/recommendation/impl/Engine.cpp

@@ -0,0 +1,259 @@
+/*
+ * 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/>.
+ */
+
+#include "Engine.hpp"
+
+#include <unordered_map>
+#include <vector>
+
+#include "ClustersEngineCreator.hpp"
+#include "FeaturesEngineCreator.hpp"
+
+#include "database/Db.hpp"
+#include "database/Session.hpp"
+#include "database/ScanSettings.hpp"
+#include "utils/Exception.hpp"
+#include "utils/Logger.hpp"
+
+namespace Recommendation
+{
+
+	static
+	std::string_view
+	engineTypeToString(EngineType engineType)
+	{
+		switch (engineType)
+		{
+			case EngineType::Clusters: return "clusters";
+			case EngineType::Features: return "features";
+		}
+
+		throw LmsException {"Internal error"};
+	}
+
+	std::unique_ptr<IEngine>
+	createEngine(Database::Db& db)
+	{
+		return std::make_unique<Engine>(db);
+	}
+
+	Engine::Engine(Database::Db& db)
+		: _db {db}
+	{
+	}
+
+	Engine::TrackContainer
+	Engine::getSimilarTracksFromTrackList(Database::TrackListId trackListId, std::size_t maxCount) const
+	{
+		TrackContainer res;
+
+		std::shared_lock lock {_enginesMutex};
+		for (const auto& engineType : _enginePriorities)
+		{
+			auto itEngine {_engines.find(engineType)};
+			if (itEngine == std::cend(_engines))
+				continue;
+
+			res = itEngine->second->getSimilarTracksFromTrackList(trackListId, maxCount);
+			if (!res.empty())
+				break;
+		}
+
+		return res;
+	}
+
+	Engine::TrackContainer
+	Engine::getSimilarTracks(const std::vector<Database::TrackId>& trackIds, std::size_t maxCount) const
+	{
+		TrackContainer res;
+
+		std::shared_lock lock {_enginesMutex};
+		for (EngineType engineType : _enginePriorities)
+		{
+			auto itEngine {_engines.find(engineType)};
+			if (itEngine == std::cend(_engines))
+				continue;
+
+			const IEngine& engine {*itEngine->second};
+			res = engine.getSimilarTracks(trackIds, maxCount);
+			if (!res.empty())
+			{
+				LMS_LOG(RECOMMENDATION, DEBUG) << "Got " << res.size() << " similar tracks using engine '" << engineTypeToString(engineType) << "'";
+				break;
+			}
+		}
+
+		return res;
+	}
+
+	Engine::ReleaseContainer
+	Engine::getSimilarReleases(Database::ReleaseId releaseId, std::size_t maxCount) const
+	{
+		ReleaseContainer res;
+
+		std::shared_lock lock {_enginesMutex};
+		for (EngineType engineType : _enginePriorities)
+		{
+			auto itEngine {_engines.find(engineType)};
+			if (itEngine == std::cend(_engines))
+				continue;
+
+			const IEngine& engine {*itEngine->second};
+			res = engine.getSimilarReleases(releaseId, maxCount);
+			if (!res.empty())
+			{
+				LMS_LOG(RECOMMENDATION, DEBUG) << "Got " << res.size() << " similar releases using engine '" << engineTypeToString(engineType) << "'";
+				break;
+			}
+
+			LMS_LOG(RECOMMENDATION, DEBUG) << "No result using engine '" << engineTypeToString(engineType) << "'";
+		}
+
+		return res;
+	}
+
+	Engine::ArtistContainer
+	Engine::getSimilarArtists(Database::ArtistId artistId, EnumSet<Database::TrackArtistLinkType> linkTypes, std::size_t maxCount) const
+	{
+		ArtistContainer res;
+
+		std::shared_lock lock {_enginesMutex};
+		for (EngineType engineType : _enginePriorities)
+		{
+			auto itEngine {_engines.find(engineType)};
+			if (itEngine == std::cend(_engines))
+				continue;
+
+			const IEngine& engine {*itEngine->second};
+			res = engine.getSimilarArtists(artistId, linkTypes, maxCount);
+			if (!res.empty())
+			{
+				LMS_LOG(RECOMMENDATION, DEBUG) << "Got " << res.size() << " similar artists using engine '" << engineTypeToString(engineType) << "'";
+				return res;
+			}
+		}
+
+		return res;
+	}
+
+	static
+	Database::ScanSettings::RecommendationEngineType
+	getRecommendationEngineType(Database::Session& session)
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		return Database::ScanSettings::get(session)->getRecommendationEngineType();
+	}
+
+	void
+	Engine::load(bool forceReload, const ProgressCallback& progressCallback)
+	{
+		using namespace Database;
+
+		LMS_LOG(RECOMMENDATION, INFO) << "Reloading recommendation engines...";
+
+		EngineContainer enginesToLoad;
+
+		{
+			std::unique_lock controlLock {_controlMutex};
+
+			{
+				std::unique_lock lock {_enginesMutex};
+				_engines.clear();
+			}
+
+			switch (getRecommendationEngineType(_db.getTLSSession()))
+			{
+				case ScanSettings::RecommendationEngineType::Clusters:
+					_enginePriorities = {EngineType::Clusters};
+					enginesToLoad.try_emplace(EngineType::Clusters, createClustersEngine(_db));
+					break;
+
+				case ScanSettings::RecommendationEngineType::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;
+			}
+
+			assert(_pendingEngines.empty());
+			for (auto& [engineType, engine] : enginesToLoad)
+				_pendingEngines.push_back(engine.get());
+		}
+
+		for (auto& [engineType, engine] : enginesToLoad)
+			loadPendingEngine(engineType, std::move(engine), forceReload, progressCallback);
+
+		_pendingEnginesCondvar.notify_all();
+
+		LMS_LOG(RECOMMENDATION, INFO) << "Recommendation engines loaded!";
+	}
+
+	void
+	Engine::loadPendingEngine(EngineType engineType, std::unique_ptr<IEngine> engine, bool forceReload, const ProgressCallback& progressCallback)
+	{
+		if (!_loadCancelled)
+		{
+			LMS_LOG(RECOMMENDATION, INFO) << "Initializing engine '" << engineTypeToString(engineType) << "'...";
+
+			auto progress {[&](const IEngine::Progress& progress)
+			{
+				progressCallback(progress);
+			}};
+
+			engine->load(forceReload, progressCallback ? progress : IEngine::ProgressCallback {});
+
+			{
+				std::scoped_lock lock {_controlMutex};
+				_pendingEngines.erase(std::find(std::begin(_pendingEngines), std::end(_pendingEngines), engine.get()));
+			}
+			LMS_LOG(RECOMMENDATION, INFO) << "Initializing engine '" << engineTypeToString(engineType) << "': " << (_loadCancelled ? "aborted" : "complete");
+		}
+
+		if (!_loadCancelled)
+		{
+			std::unique_lock lock {_enginesMutex};
+			_engines.emplace(engineType, std::move(engine));
+		}
+	}
+
+	void
+	Engine::cancelLoad()
+	{
+		LMS_LOG(RECOMMENDATION, DEBUG) << "Cancelling loading...";
+
+		std::unique_lock controlLock {_controlMutex};
+
+		assert(!_loadCancelled);
+		_loadCancelled = true;
+
+		LMS_LOG(RECOMMENDATION, DEBUG) << "Still " <<  _pendingEngines.size() << " pending engines!";
+
+		for (IEngine* engine : _pendingEngines)
+			engine->requestCancelLoad();
+
+		_pendingEnginesCondvar.wait(controlLock, [this] {return _pendingEngines.empty();});
+		_loadCancelled = false;
+
+		LMS_LOG(RECOMMENDATION, DEBUG) << "Cancelling loading DONE";
+	}
+
+} // ns Similarity

src/libs/services/recommendation/impl/Engine.hpp

@@ -0,0 +1,85 @@
+/*
+ * 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 <condition_variable>
+#include <mutex>
+#include <shared_mutex>
+#include <unordered_map>
+#include <vector>
+
+#include "recommendation/IEngine.hpp"
+
+namespace Database
+{
+	class Db;
+}
+
+namespace Recommendation
+{
+	enum class EngineType
+	{
+		Clusters,
+		Features,
+	};
+
+	class Engine : public IEngine
+	{
+		public:
+			Engine(Database::Db& db);
+			~Engine() = default;
+
+			Engine(const Engine&) = delete;
+			Engine(Engine&&) = delete;
+			Engine& operator=(const Engine&) = delete;
+			Engine& operator=(Engine&&) = delete;
+
+		private:
+			void	load(bool forceReload, const ProgressCallback& progressCallback) override;
+			void	cancelLoad() override;
+			void	requestCancelLoad() override {};
+
+			TrackContainer getSimilarTracksFromTrackList(Database::TrackListId tracklistId, std::size_t maxCount) const override;
+			TrackContainer getSimilarTracks(const std::vector<Database::TrackId>& tracksId, std::size_t maxCount) const override;
+			ReleaseContainer getSimilarReleases(Database::ReleaseId releaseId, std::size_t maxCount) const override;
+			ArtistContainer getSimilarArtists(Database::ArtistId artistId, EnumSet<Database::TrackArtistLinkType> linkTypes, std::size_t maxCount) const override;
+
+			void setEnginePriorities(const std::vector<EngineType>& engineTypes);
+			void clearEngines();
+			void loadPendingEngine(EngineType engineType, std::unique_ptr<IEngine> engine, bool forceReload, const ProgressCallback& progressCallback);
+
+			Database::Db&				_db;
+
+			std::mutex					_controlMutex;
+			bool						_loadCancelled {};
+
+			using EngineContainer = std::unordered_map<EngineType, std::unique_ptr<IEngine>>;
+			EngineContainer				_engines;
+			mutable std::shared_mutex	_enginesMutex;
+
+			std::vector<IEngine*>		_pendingEngines;
+			std::shared_mutex			_pendingEnginesMutex;
+			std::condition_variable 	_pendingEnginesCondvar;
+
+			std::vector<EngineType>		_enginePriorities; // ordered by priority
+	};
+
+} // ns Recommendation
+

src/libs/services/recommendation/impl/FeaturesEngineCreator.hpp

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2020 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 "recommendation/IEngine.hpp"
+
+namespace Database
+{
+	class Db;
+}
+
+namespace Recommendation
+{
+	std::unique_ptr<IEngine> createFeaturesEngine(Database::Db& db);
+}
+

src/libs/services/recommendation/impl/clusters/ClustersEngine.cpp

@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2018 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 "ClustersEngine.hpp"
+
+#include "database/Artist.hpp"
+#include "database/Cluster.hpp"
+#include "database/Db.hpp"
+#include "database/Release.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "database/TrackList.hpp"
+
+namespace Recommendation {
+
+std::unique_ptr<IEngine> createClustersEngine(Database::Db& db)
+{
+	return std::make_unique<ClusterEngine>(db);
+}
+
+IEngine::TrackContainer
+ClusterEngine::getSimilarTracks(const std::vector<Database::TrackId>& trackIds, std::size_t maxCount) const
+{
+	Database::Session& dbSession {_db.getTLSSession()};
+
+	TrackContainer res;
+
+	{
+		auto transaction {dbSession.createSharedTransaction()};
+
+		const auto tracks {Database::Track::getSimilarTracks(dbSession, trackIds, 0, maxCount)};
+		res.reserve(tracks.size());
+		std::transform(std::cbegin(tracks), std::cend(tracks), std::back_inserter(res), [](const auto& track) { return track->getId(); });
+	}
+
+	return res;
+}
+
+IEngine::ResultContainer<Database::TrackId>
+ClusterEngine::getSimilarTracksFromTrackList(Database::TrackListId tracklistId, std::size_t maxCount) const
+{
+	Database::Session& dbSession {_db.getTLSSession()};
+
+	TrackContainer res;
+
+	{
+		auto transaction {dbSession.createSharedTransaction()};
+
+		const Database::TrackList::pointer trackList {Database::TrackList::getById(dbSession, tracklistId)};
+		if (!trackList)
+			return res;
+
+		const auto tracks {trackList->getSimilarTracks(0, maxCount)};
+		res.reserve(tracks.size());
+		std::transform(std::cbegin(tracks), std::cend(tracks), std::back_inserter(res), [](const auto& track) { return track->getId(); });
+	}
+
+	return res;
+}
+
+IEngine::ResultContainer<Database::ReleaseId>
+ClusterEngine::getSimilarReleases(Database::ReleaseId releaseId, std::size_t maxCount) const
+{
+	Database::Session& dbSession {_db.getTLSSession()};
+
+	ReleaseContainer res;
+	{
+		auto transaction {dbSession.createSharedTransaction()};
+
+		auto release {Database::Release::getById(dbSession, releaseId)};
+		if (!release)
+			return res;
+
+		const auto releases {release->getSimilarReleases(0, maxCount)};
+		res.reserve(releases.size());
+		std::transform(std::cbegin(releases), std::cend(releases), std::back_inserter(res), [](const auto& release) { return release->getId(); });
+	}
+
+	return res;
+}
+
+IEngine::ResultContainer<Database::ArtistId>
+ClusterEngine::getSimilarArtists(Database::ArtistId artistId, EnumSet<Database::TrackArtistLinkType> artistLinkTypes, std::size_t maxCount) const
+{
+	Database::Session& dbSession {_db.getTLSSession()};
+
+	ResultContainer<Database::ArtistId> res;
+	{
+		auto transaction {dbSession.createSharedTransaction()};
+
+		auto artist {Database::Artist::getById(dbSession, artistId)};
+		if (!artist)
+			return res;
+
+		const auto artists {artist->getSimilarArtists(artistLinkTypes, Database::Range {0, maxCount})};
+		res.reserve(artists.size());
+		std::transform(std::cbegin(artists), std::cend(artists), std::back_inserter(res), [](const auto& artist) { return artist->getId(); });
+	}
+
+	return res;
+}
+
+} // namespace Recommendation

src/libs/services/recommendation/impl/clusters/ClustersEngine.hpp

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2018 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 "recommendation/IEngine.hpp"
+
+namespace Recommendation
+{
+
+	class ClusterEngine : public IEngine
+	{
+		public:
+			ClusterEngine(Database::Db& db) : _db {db} {}
+
+			ClusterEngine(const ClusterEngine&) = delete;
+			ClusterEngine(ClusterEngine&&) = delete;
+			ClusterEngine& operator=(const ClusterEngine&) = delete;
+			ClusterEngine& operator=(ClusterEngine&&) = delete;
+
+		private:
+			void load(bool, const ProgressCallback&) override {}
+			void requestCancelLoad() override {}
+			void cancelLoad() {}
+
+			TrackContainer		getSimilarTracksFromTrackList(Database::TrackListId tracklistId, std::size_t maxCount) const override;
+			TrackContainer		getSimilarTracks(const std::vector<Database::TrackId>& tracksId, std::size_t maxCount) const override;
+			ReleaseContainer	getSimilarReleases(Database::ReleaseId releaseId, std::size_t maxCount) const override;
+			ArtistContainer		getSimilarArtists(Database::ArtistId artistId, EnumSet<Database::TrackArtistLinkType> linkTypes, std::size_t maxCount) const override;
+
+			Database::Db& _db;
+	};
+
+} // namespace Recommendation
+

src/libs/services/recommendation/impl/features/FeaturesDefs.cpp

@@ -0,0 +1,393 @@
+/*
+ * 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/>.
+ */
+
+#include "FeaturesDefs.hpp"
+
+#include <algorithm>
+#include <iterator>
+
+#include "utils/Exception.hpp"
+
+namespace Recommendation {
+
+static const std::unordered_map<FeatureName, FeatureDef> featureDefinitions
+{
+	{ "lowlevel.average_loudness",			{1}},
+	{ "lowlevel.barkbands.dmean",			{27}},
+	{ "lowlevel.barkbands.dmean2",			{27}},
+	{ "lowlevel.barkbands.dvar",			{27}},
+	{ "lowlevel.barkbands.dvar2",			{27}},
+	{ "lowlevel.barkbands.max",			{27}},
+	{ "lowlevel.barkbands.mean",			{27}},
+	{ "lowlevel.barkbands.median",			{27}},
+	{ "lowlevel.barkbands.min",			{27}},
+	{ "lowlevel.barkbands.var",			{27}},
+	{ "lowlevel.barkbands_crest.dmean",		{1}},
+	{ "lowlevel.barkbands_crest.dmean2",		{1}},
+	{ "lowlevel.barkbands_crest.dvar",		{1}},
+	{ "lowlevel.barkbands_crest.dvar2",		{1}},
+	{ "lowlevel.barkbands_crest.max",		{1}},
+	{ "lowlevel.barkbands_crest.mean",		{1}},
+	{ "lowlevel.barkbands_crest.median",		{1}},
+	{ "lowlevel.barkbands_crest.min",		{1}},
+	{ "lowlevel.barkbands_crest.var",		{1}},
+	{ "lowlevel.barkbands_flatness_db.dmean",	{1}},
+	{ "lowlevel.barkbands_flatness_db.dmean2",	{1}},
+	{ "lowlevel.barkbands_flatness_db.dvar",	{1}},
+	{ "lowlevel.barkbands_flatness_db.dvar2",	{1}},
+	{ "lowlevel.barkbands_flatness_db.max",		{1}},
+	{ "lowlevel.barkbands_flatness_db.mean",	{1}},
+	{ "lowlevel.barkbands_flatness_db.median",	{1}},
+	{ "lowlevel.barkbands_flatness_db.min",		{1}},
+	{ "lowlevel.barkbands_flatness_db.var",		{1}},
+	{ "lowlevel.barkbands_kurtosis.dmean",		{1}},
+	{ "lowlevel.barkbands_kurtosis.dmean2",		{1}},
+	{ "lowlevel.barkbands_kurtosis.dvar",		{1}},
+	{ "lowlevel.barkbands_kurtosis.dvar2",		{1}},
+	{ "lowlevel.barkbands_kurtosis.max",		{1}},
+	{ "lowlevel.barkbands_kurtosis.mean",		{1}},
+	{ "lowlevel.barkbands_kurtosis.median",		{1}},
+	{ "lowlevel.barkbands_kurtosis.min",		{1}},
+	{ "lowlevel.barkbands_kurtosis.var",		{1}},
+	{ "lowlevel.barkbands_skewness.dmean",		{1}},
+	{ "lowlevel.barkbands_skewness.dmean2",		{1}},
+	{ "lowlevel.barkbands_skewness.dvar",		{1}},
+	{ "lowlevel.barkbands_skewness.dvar2",		{1}},
+	{ "lowlevel.barkbands_skewness.max",		{1}},
+	{ "lowlevel.barkbands_skewness.mean",		{1}},
+	{ "lowlevel.barkbands_skewness.median",		{1}},
+	{ "lowlevel.barkbands_skewness.min",		{1}},
+	{ "lowlevel.barkbands_skewness.var",		{1}},
+	{ "lowlevel.barkbands_spread.dmean",		{1}},
+	{ "lowlevel.barkbands_spread.dmean2",		{1}},
+	{ "lowlevel.barkbands_spread.dvar",		{1}},
+	{ "lowlevel.barkbands_spread.dvar2",		{1}},
+	{ "lowlevel.barkbands_spread.max",		{1}},
+	{ "lowlevel.barkbands_spread.mean",		{1}},
+	{ "lowlevel.barkbands_spread.median",		{1}},
+	{ "lowlevel.barkbands_spread.min",		{1}},
+	{ "lowlevel.barkbands_spread.var",		{1}},
+	{ "lowlevel.dissonance.dmean",			{1}},
+	{ "lowlevel.dissonance.dmean2",			{1}},
+	{ "lowlevel.dissonance.dvar",			{1}},
+	{ "lowlevel.dissonance.dvar2",			{1}},
+	{ "lowlevel.dissonance.max",			{1}},
+	{ "lowlevel.dissonance.mean",			{1}},
+	{ "lowlevel.dissonance.median",			{1}},
+	{ "lowlevel.dissonance.min",			{1}},
+	{ "lowlevel.dissonance.var",			{1}},
+	{ "lowlevel.dynamic_complexity",		{1}},
+	{ "lowlevel.erbbands.dmean",			{40}},
+	{ "lowlevel.erbbands.dmean2",			{40}},
+	{ "lowlevel.erbbands.dvar",			{40}},
+	{ "lowlevel.erbbands.dvar2",			{40}},
+	{ "lowlevel.erbbands.max",			{40}},
+	{ "lowlevel.erbbands.mean",			{40}},
+	{ "lowlevel.erbbands.median",			{40}},
+	{ "lowlevel.erbbands.min",			{40}},
+	{ "lowlevel.erbbands.var",			{40}},
+	{ "lowlevel.gfcc.mean",				{13}},
+	{ "lowlevel.hfc.dmean",				{1}},
+	{ "lowlevel.hfc.dmean2",			{1}},
+	{ "lowlevel.hfc.dvar",				{1}},
+	{ "lowlevel.hfc.dvar2",				{1}},
+	{ "lowlevel.hfc.max",				{1}},
+	{ "lowlevel.hfc.mean",				{1}},
+	{ "lowlevel.hfc.median",			{1}},
+	{ "lowlevel.hfc.min",				{1}},
+	{ "lowlevel.hfc.var",				{1}},
+	{ "tonal.hpcp.median",				{36}},
+	{ "lowlevel.melbands.dmean",			{40}},
+	{ "lowlevel.melbands.dmean2",			{40}},
+	{ "lowlevel.melbands.dvar",			{40}},
+	{ "lowlevel.melbands.dvar2",			{40}},
+	{ "lowlevel.melbands.max",			{40}},
+	{ "lowlevel.melbands.mean",			{40}},
+	{ "lowlevel.melbands.median",			{40}},
+	{ "lowlevel.melbands.min",			{40}},
+	{ "lowlevel.melbands.var",			{40}},
+	{ "lowlevel.melbands_crest.dmean",		{1}},
+	{ "lowlevel.melbands_crest.dmean2",		{1}},
+	{ "lowlevel.melbands_crest.dvar",		{1}},
+	{ "lowlevel.melbands_crest.dvar2",		{1}},
+	{ "lowlevel.melbands_crest.max",		{1}},
+	{ "lowlevel.melbands_crest.mean",		{1}},
+	{ "lowlevel.melbands_crest.median",		{1}},
+	{ "lowlevel.melbands_crest.min",		{1}},
+	{ "lowlevel.melbands_crest.var",		{1}},
+	{ "lowlevel.melbands_flatness_db.dmean",	{1}},
+	{ "lowlevel.melbands_flatness_db.dmean2",	{1}},
+	{ "lowlevel.melbands_flatness_db.dvar",		{1}},
+	{ "lowlevel.melbands_flatness_db.dvar2",	{1}},
+	{ "lowlevel.melbands_flatness_db.max",		{1}},
+	{ "lowlevel.melbands_flatness_db.mean",		{1}},
+	{ "lowlevel.melbands_flatness_db.median",	{1}},
+	{ "lowlevel.melbands_flatness_db.min",		{1}},
+	{ "lowlevel.melbands_flatness_db.var",		{1}},
+	{ "lowlevel.melbands_kurtosis.dmean",		{1}},
+	{ "lowlevel.melbands_kurtosis.dmean2",		{1}},
+	{ "lowlevel.melbands_kurtosis.dvar",		{1}},
+	{ "lowlevel.melbands_kurtosis.dvar2",		{1}},
+	{ "lowlevel.melbands_kurtosis.max",		{1}},
+	{ "lowlevel.melbands_kurtosis.mean",		{1}},
+	{ "lowlevel.melbands_kurtosis.median",		{1}},
+	{ "lowlevel.melbands_kurtosis.min",		{1}},
+	{ "lowlevel.melbands_kurtosis.var",		{1}},
+	{ "lowlevel.melbands_skewness.dmean",		{1}},
+	{ "lowlevel.melbands_skewness.dmean2",		{1}},
+	{ "lowlevel.melbands_skewness.dvar",		{1}},
+	{ "lowlevel.melbands_skewness.dvar2",		{1}},
+	{ "lowlevel.melbands_skewness.max",		{1}},
+	{ "lowlevel.melbands_skewness.mean",		{1}},
+	{ "lowlevel.melbands_skewness.median",		{1}},
+	{ "lowlevel.melbands_skewness.min",		{1}},
+	{ "lowlevel.melbands_skewness.var",		{1}},
+	{ "lowlevel.melbands_spread.dmean",		{1}},
+	{ "lowlevel.melbands_spread.dmean2",		{1}},
+	{ "lowlevel.melbands_spread.dvar",		{1}},
+	{ "lowlevel.melbands_spread.dvar2",		{1}},
+	{ "lowlevel.melbands_spread.max",		{1}},
+	{ "lowlevel.melbands_spread.mean",		{1}},
+	{ "lowlevel.melbands_spread.median",		{1}},
+	{ "lowlevel.melbands_spread.min",		{1}},
+	{ "lowlevel.melbands_spread.var",		{1}},
+	{ "lowlevel.mfcc.mean",				{13}},
+	{ "lowlevel.pitch_salience.dmean",		{1}},
+	{ "lowlevel.pitch_salience.dmean2",		{1}},
+	{ "lowlevel.pitch_salience.dvar",		{1}},
+	{ "lowlevel.pitch_salience.dvar2",		{1}},
+	{ "lowlevel.pitch_salience.max",		{1}},
+	{ "lowlevel.pitch_salience.mean",		{1}},
+	{ "lowlevel.pitch_salience.median",		{1}},
+	{ "lowlevel.pitch_salience.min",		{1}},
+	{ "lowlevel.pitch_salience.var",		{1}},
+	{ "lowlevel.silence_rate_30dB.dmean",		{1}},
+	{ "lowlevel.silence_rate_30dB.dmean2",		{1}},
+	{ "lowlevel.silence_rate_30dB.dvar",		{1}},
+	{ "lowlevel.silence_rate_30dB.dvar2",		{1}},
+	{ "lowlevel.silence_rate_30dB.max",		{1}},
+	{ "lowlevel.silence_rate_30dB.mean",		{1}},
+	{ "lowlevel.silence_rate_30dB.median",		{1}},
+	{ "lowlevel.silence_rate_30dB.min",		{1}},
+	{ "lowlevel.silence_rate_30dB.var",		{1}},
+	{ "lowlevel.silence_rate_60dB.dmean",		{1}},
+	{ "lowlevel.silence_rate_60dB.dmean2",		{1}},
+	{ "lowlevel.silence_rate_60dB.dvar",		{1}},
+	{ "lowlevel.silence_rate_60dB.dvar2",		{1}},
+	{ "lowlevel.silence_rate_60dB.max",		{1}},
+	{ "lowlevel.silence_rate_60dB.mean",		{1}},
+	{ "lowlevel.silence_rate_60dB.median",		{1}},
+	{ "lowlevel.silence_rate_60dB.min",		{1}},
+	{ "lowlevel.silence_rate_60dB.var",		{1}},
+	{ "lowlevel.spectral_centroid.dmean",		{1}},
+	{ "lowlevel.spectral_centroid.dmean2",		{1}},
+	{ "lowlevel.spectral_centroid.dvar",		{1}},
+	{ "lowlevel.spectral_centroid.dvar2",		{1}},
+	{ "lowlevel.spectral_centroid.max",		{1}},
+	{ "lowlevel.spectral_centroid.mean",		{1}},
+	{ "lowlevel.spectral_centroid.median",		{1}},
+	{ "lowlevel.spectral_centroid.min",		{1}},
+	{ "lowlevel.spectral_centroid.var",		{1}},
+	{ "lowlevel.spectral_complexity.dmean",		{1}},
+	{ "lowlevel.spectral_complexity.dmean2",	{1}},
+	{ "lowlevel.spectral_complexity.dvar",		{1}},
+	{ "lowlevel.spectral_complexity.dvar2",		{1}},
+	{ "lowlevel.spectral_complexity.max",		{1}},
+	{ "lowlevel.spectral_complexity.mean",		{1}},
+	{ "lowlevel.spectral_complexity.median",	{1}},
+	{ "lowlevel.spectral_complexity.min",		{1}},
+	{ "lowlevel.spectral_complexity.var",		{1}},
+	{ "lowlevel.spectral_contrast_coeffs.dmean",	{6}},
+	{ "lowlevel.spectral_contrast_coeffs.dmean2",	{6}},
+	{ "lowlevel.spectral_contrast_coeffs.dvar",	{6}},
+	{ "lowlevel.spectral_contrast_coeffs.dvar2",	{6}},
+	{ "lowlevel.spectral_contrast_coeffs.max",	{6}},
+	{ "lowlevel.spectral_contrast_coeffs.mean",	{6}},
+	{ "lowlevel.spectral_contrast_coeffs.median",	{6}},
+	{ "lowlevel.spectral_contrast_coeffs.min",	{6}},
+	{ "lowlevel.spectral_contrast_coeffs.var",	{6}},
+	{ "lowlevel.spectral_contrast_valleys.dmean",	{6}},
+	{ "lowlevel.spectral_contrast_valleys.dmean2",	{6}},
+	{ "lowlevel.spectral_contrast_valleys.dvar",	{6}},
+	{ "lowlevel.spectral_contrast_valleys.dvar2",	{6}},
+	{ "lowlevel.spectral_contrast_valleys.max",	{6}},
+	{ "lowlevel.spectral_contrast_valleys.mean",	{6}},
+	{ "lowlevel.spectral_contrast_valleys.median",	{6}},
+	{ "lowlevel.spectral_contrast_valleys.min",	{6}},
+	{ "lowlevel.spectral_contrast_valleys.var",	{6}},
+	{ "lowlevel.spectral_decrease.dmean",		{1}},
+	{ "lowlevel.spectral_decrease.dmean2",		{1}},
+	{ "lowlevel.spectral_decrease.dvar",		{1}},
+	{ "lowlevel.spectral_decrease.dvar2",		{1}},
+	{ "lowlevel.spectral_decrease.max",		{1}},
+	{ "lowlevel.spectral_decrease.mean",		{1}},
+	{ "lowlevel.spectral_decrease.median",		{1}},
+	{ "lowlevel.spectral_decrease.min",		{1}},
+	{ "lowlevel.spectral_decrease.var",		{1}},
+	{ "lowlevel.spectral_energy.dmean",		{1}},
+	{ "lowlevel.spectral_energy.dmean2",		{1}},
+	{ "lowlevel.spectral_energy.dvar",		{1}},
+	{ "lowlevel.spectral_energy.dvar2",		{1}},
+	{ "lowlevel.spectral_energy.max",		{1}},
+	{ "lowlevel.spectral_energy.mean",		{1}},
+	{ "lowlevel.spectral_energy.median",		{1}},
+	{ "lowlevel.spectral_energy.min",		{1}},
+	{ "lowlevel.spectral_energy.var",		{1}},
+	{ "lowlevel.spectral_energyband_high.dmean",		{1}},
+	{ "lowlevel.spectral_energyband_high.dmean2",		{1}},
+	{ "lowlevel.spectral_energyband_high.dvar",		{1}},
+	{ "lowlevel.spectral_energyband_high.dvar2",		{1}},
+	{ "lowlevel.spectral_energyband_high.max",		{1}},
+	{ "lowlevel.spectral_energyband_high.mean",		{1}},
+	{ "lowlevel.spectral_energyband_high.median",		{1}},
+	{ "lowlevel.spectral_energyband_high.min",		{1}},
+	{ "lowlevel.spectral_energyband_high.var",		{1}},
+	{ "lowlevel.spectral_energyband_low.dmean",		{1}},
+	{ "lowlevel.spectral_energyband_low.dmean2",		{1}},
+	{ "lowlevel.spectral_energyband_low.dvar",		{1}},
+	{ "lowlevel.spectral_energyband_low.dvar2",		{1}},
+	{ "lowlevel.spectral_energyband_low.max",		{1}},
+	{ "lowlevel.spectral_energyband_low.mean",		{1}},
+	{ "lowlevel.spectral_energyband_low.median",		{1}},
+	{ "lowlevel.spectral_energyband_low.min",		{1}},
+	{ "lowlevel.spectral_energyband_low.var",		{1}},
+	{ "lowlevel.spectral_energyband_middle_high.dmean",		{1}},
+	{ "lowlevel.spectral_energyband_middle_high.dmean2",		{1}},
+	{ "lowlevel.spectral_energyband_middle_high.dvar",		{1}},
+	{ "lowlevel.spectral_energyband_middle_high.dvar2",		{1}},
+	{ "lowlevel.spectral_energyband_middle_high.max",		{1}},
+	{ "lowlevel.spectral_energyband_middle_high.mean",		{1}},
+	{ "lowlevel.spectral_energyband_middle_high.median",		{1}},
+	{ "lowlevel.spectral_energyband_middle_high.min",		{1}},
+	{ "lowlevel.spectral_energyband_middle_high.var",		{1}},
+	{ "lowlevel.spectral_energyband_middle_low.dmean",		{1}},
+	{ "lowlevel.spectral_energyband_middle_low.dmean2",		{1}},
+	{ "lowlevel.spectral_energyband_middle_low.dvar",		{1}},
+	{ "lowlevel.spectral_energyband_middle_low.dvar2",		{1}},
+	{ "lowlevel.spectral_energyband_middle_low.max",		{1}},
+	{ "lowlevel.spectral_energyband_middle_low.mean",		{1}},
+	{ "lowlevel.spectral_energyband_middle_low.median",		{1}},
+	{ "lowlevel.spectral_energyband_middle_low.min",		{1}},
+	{ "lowlevel.spectral_energyband_middle_low.var",		{1}},
+	{ "lowlevel.spectral_entropy.dmean",		{1}},
+	{ "lowlevel.spectral_entropy.dmean2",		{1}},
+	{ "lowlevel.spectral_entropy.dvar",		{1}},
+	{ "lowlevel.spectral_entropy.dvar2",		{1}},
+	{ "lowlevel.spectral_entropy.max",		{1}},
+	{ "lowlevel.spectral_entropy.mean",		{1}},
+	{ "lowlevel.spectral_entropy.median",		{1}},
+	{ "lowlevel.spectral_entropy.min",		{1}},
+	{ "lowlevel.spectral_entropy.var",		{1}},
+	{ "lowlevel.spectral_flux.dmean",		{1}},
+	{ "lowlevel.spectral_flux.dmean2",		{1}},
+	{ "lowlevel.spectral_flux.dvar",		{1}},
+	{ "lowlevel.spectral_flux.dvar2",		{1}},
+	{ "lowlevel.spectral_flux.max",			{1}},
+	{ "lowlevel.spectral_flux.mean",		{1}},
+	{ "lowlevel.spectral_flux.median",		{1}},
+	{ "lowlevel.spectral_flux.min",			{1}},
+	{ "lowlevel.spectral_flux.var",			{1}},
+	{ "lowlevel.spectral_kurtosis.dmean",		{1}},
+	{ "lowlevel.spectral_kurtosis.dmean2",		{1}},
+	{ "lowlevel.spectral_kurtosis.dvar",		{1}},
+	{ "lowlevel.spectral_kurtosis.dvar2",		{1}},
+	{ "lowlevel.spectral_kurtosis.max",		{1}},
+	{ "lowlevel.spectral_kurtosis.mean",		{1}},
+	{ "lowlevel.spectral_kurtosis.median",		{1}},
+	{ "lowlevel.spectral_kurtosis.min",		{1}},
+	{ "lowlevel.spectral_kurtosis.var",		{1}},
+	{ "lowlevel.spectral_rms.dmean",		{1}},
+	{ "lowlevel.spectral_rms.dmean2",		{1}},
+	{ "lowlevel.spectral_rms.dvar",			{1}},
+	{ "lowlevel.spectral_rms.dvar2",		{1}},
+	{ "lowlevel.spectral_rms.max",			{1}},
+	{ "lowlevel.spectral_rms.mean",			{1}},
+	{ "lowlevel.spectral_rms.median",		{1}},
+	{ "lowlevel.spectral_rms.min",			{1}},
+	{ "lowlevel.spectral_rms.var",			{1}},
+	{ "lowlevel.spectral_rolloff.dmean",		{1}},
+	{ "lowlevel.spectral_rolloff.dmean2",		{1}},
+	{ "lowlevel.spectral_rolloff.dvar",		{1}},
+	{ "lowlevel.spectral_rolloff.dvar2",		{1}},
+	{ "lowlevel.spectral_rolloff.max",		{1}},
+	{ "lowlevel.spectral_rolloff.mean",		{1}},
+	{ "lowlevel.spectral_rolloff.median",		{1}},
+	{ "lowlevel.spectral_rolloff.min",		{1}},
+	{ "lowlevel.spectral_rolloff.var",		{1}},
+	{ "lowlevel.spectral_skewness.dmean",		{1}},
+	{ "lowlevel.spectral_skewness.dmean2",		{1}},
+	{ "lowlevel.spectral_skewness.dvar",		{1}},
+	{ "lowlevel.spectral_skewness.dvar2",		{1}},
+	{ "lowlevel.spectral_skewness.max",		{1}},
+	{ "lowlevel.spectral_skewness.mean",		{1}},
+	{ "lowlevel.spectral_skewness.median",		{1}},
+	{ "lowlevel.spectral_skewness.min",		{1}},
+	{ "lowlevel.spectral_skewness.var",		{1}},
+	{ "lowlevel.spectral_spread.dmean",		{1}},
+	{ "lowlevel.spectral_spread.dmean2",		{1}},
+	{ "lowlevel.spectral_spread.dvar",		{1}},
+	{ "lowlevel.spectral_spread.dvar2",		{1}},
+	{ "lowlevel.spectral_spread.max",		{1}},
+	{ "lowlevel.spectral_spread.mean",		{1}},
+	{ "lowlevel.spectral_spread.median",		{1}},
+	{ "lowlevel.spectral_spread.min",		{1}},
+	{ "lowlevel.spectral_spread.var",		{1}},
+	{ "lowlevel.spectral_strongpeak.dmean",		{1}},
+	{ "lowlevel.spectral_strongpeak.dmean2",	{1}},
+	{ "lowlevel.spectral_strongpeak.dvar",		{1}},
+	{ "lowlevel.spectral_strongpeak.dvar2",		{1}},
+	{ "lowlevel.spectral_strongpeak.max",		{1}},
+	{ "lowlevel.spectral_strongpeak.mean",		{1}},
+	{ "lowlevel.spectral_strongpeak.median",	{1}},
+	{ "lowlevel.spectral_strongpeak.min",		{1}},
+	{ "lowlevel.spectral_strongpeak.var",		{1}},
+	{ "lowlevel.zerocrossingrate.dmean",		{1}},
+	{ "lowlevel.zerocrossingrate.dmean2",		{1}},
+	{ "lowlevel.zerocrossingrate.dvar",		{1}},
+	{ "lowlevel.zerocrossingrate.dvar2",		{1}},
+	{ "lowlevel.zerocrossingrate.max",		{1}},
+	{ "lowlevel.zerocrossingrate.mean",		{1}},
+	{ "lowlevel.zerocrossingrate.median",		{1}},
+	{ "lowlevel.zerocrossingrate.min",		{1}},
+	{ "lowlevel.zerocrossingrate.var",		{1}},
+};
+
+FeatureDef
+getFeatureDef(const FeatureName& featureName)
+{
+	auto it {featureDefinitions.find(featureName)};
+	if (it == std::cend(featureDefinitions))
+		throw LmsException {"Unhandled requested feature '" + featureName + "'"};
+
+	return it->second;
+}
+
+FeatureNames
+getFeatureNames()
+{
+	FeatureNames res;
+
+	std::transform(std::cbegin(featureDefinitions), std::cend(featureDefinitions),
+			std::inserter(res, std::begin(res)), [](auto itFeature) { return itFeature.first; });
+
+	return res;
+}
+
+} // namespace Recommendation
+

src/libs/services/recommendation/impl/features/FeaturesDefs.hpp

@@ -0,0 +1,49 @@
+/*
+ * 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 <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace Recommendation {
+
+using FeatureName = std::string;
+using FeatureNames = std::unordered_set<FeatureName>;
+using FeatureValue = double;
+using FeatureValues = std::vector<FeatureValue>;
+using FeatureValuesMap = std::unordered_map<FeatureName, FeatureValues>;
+
+struct FeatureDef
+{
+	std::size_t nbDimensions {};
+};
+
+FeatureDef getFeatureDef(const FeatureName& featureName);
+FeatureNames getFeatureNames();
+
+struct FeatureSettings
+{
+	double weight {};
+};
+using FeatureSettingsMap = std::unordered_map<FeatureName, FeatureSettings>;
+
+} // namespace Recommendation

src/libs/services/recommendation/impl/features/FeaturesEngine.cpp

@@ -0,0 +1,455 @@
+/*
+ * Copyright (C) 2018 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 "FeaturesEngine.hpp"
+
+#include <numeric>
+
+#include "database/Artist.hpp"
+#include "database/Db.hpp"
+#include "database/Release.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "database/TrackArtistLink.hpp"
+#include "database/TrackFeatures.hpp"
+#include "database/TrackList.hpp"
+#include "som/DataNormalizer.hpp"
+#include "utils/Logger.hpp"
+#include "utils/Random.hpp"
+
+
+namespace Recommendation {
+
+std::unique_ptr<IEngine> createFeaturesEngine(Database::Db& db)
+{
+	return std::make_unique<FeaturesEngine>(db);
+}
+
+const FeatureSettingsMap&
+FeaturesEngine::getDefaultTrainFeatureSettings()
+{
+	static const FeatureSettingsMap defaultTrainFeatureSettings
+	{
+		{ "lowlevel.spectral_energyband_high.mean",	{1}},
+		{ "lowlevel.spectral_rolloff.median",		{1}},
+		{ "lowlevel.spectral_contrast_valleys.var",	{1}},
+		{ "lowlevel.erbbands.mean",			{1}},
+		{ "lowlevel.gfcc.mean",				{1}},
+	};
+
+	return defaultTrainFeatureSettings;
+}
+
+static
+std::optional<FeatureValuesMap>
+getTrackFeatureValues(FeaturesEngine::FeaturesFetchFunc func, Database::TrackId trackId, const std::unordered_set<FeatureName>& featureNames)
+{
+	return func(trackId, featureNames);
+}
+
+static
+std::optional<FeatureValuesMap>
+getTrackFeatureValuesFromDb(Database::Session& session, Database::TrackId trackId, const std::unordered_set<FeatureName>& featureNames)
+{
+	auto func = [&](Database::TrackId trackId, const std::unordered_set<FeatureName>& featureNames)
+	{
+		std::optional<FeatureValuesMap> res;
+
+		auto transaction {session.createSharedTransaction()};
+
+		Database::Track::pointer track {Database::Track::getById(session, trackId)};
+		if (!track)
+			return res;
+
+		res = track->getTrackFeatures()->getFeatureValuesMap(featureNames);
+		if (res->empty())
+			res.reset();
+
+		return res;
+	};
+
+	return getTrackFeatureValues(func, trackId, featureNames);
+}
+
+static
+std::optional<SOM::InputVector>
+convertFeatureValuesMapToInputVector(const FeatureValuesMap& featureValuesMap, std::size_t nbDimensions)
+{
+	std::size_t i {};
+	std::optional<SOM::InputVector> res {SOM::InputVector {nbDimensions}};
+	for (const auto& [featureName, values] : featureValuesMap)
+	{
+		if (values.size() != getFeatureDef(featureName).nbDimensions)
+		{
+			LMS_LOG(RECOMMENDATION, WARNING) << "Dimension mismatch for feature '" << featureName << "'. Expected " << getFeatureDef(featureName).nbDimensions << ", got " << values.size();
+			res.reset();
+			break;
+		}
+
+		for (double val : values)
+			(*res)[i++] = val;
+	}
+
+	return res;
+}
+
+static
+SOM::InputVector
+getInputVectorWeights(const FeatureSettingsMap& featureSettingsMap, std::size_t nbDimensions)
+{
+	SOM::InputVector weights {nbDimensions};
+	std::size_t index {};
+	for (const auto& [featureName, featureSettings] : featureSettingsMap)
+	{
+		const std::size_t featureNbDimensions {getFeatureDef(featureName).nbDimensions};
+
+		for (std::size_t i {}; i < featureNbDimensions; ++i)
+			weights[index++] = (1. / featureNbDimensions * featureSettings.weight);
+	}
+
+	assert(index == nbDimensions);
+
+	return weights;
+}
+
+void
+FeaturesEngine::loadFromTraining(const TrainSettings& trainSettings, const ProgressCallback& progressCallback)
+{
+	LMS_LOG(RECOMMENDATION, INFO) << "Constructing features classifier...";
+
+	std::unordered_set<FeatureName> featureNames;
+	std::transform(std::cbegin(trainSettings.featureSettingsMap), std::cend(trainSettings.featureSettingsMap), std::inserter(featureNames, std::begin(featureNames)),
+		[](const auto& itFeatureSetting) { return itFeatureSetting.first; });
+
+	const std::size_t nbDimensions {std::accumulate(std::cbegin(featureNames), std::cend(featureNames), std::size_t {0},
+			[](std::size_t sum, const FeatureName& featureName) { return sum + getFeatureDef(featureName).nbDimensions; })};
+
+	LMS_LOG(RECOMMENDATION, DEBUG) << "Features dimension = " << nbDimensions;
+
+	Database::Session& session {_db.getTLSSession()};
+
+	std::vector<Database::TrackId> trackIds;
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		LMS_LOG(RECOMMENDATION, DEBUG) << "Getting Tracks with features...";
+		trackIds = Database::Track::getAllIdsWithFeatures(session);
+		LMS_LOG(RECOMMENDATION, DEBUG) << "Getting Tracks with features DONE (found " << trackIds.size() << " tracks)";
+	}
+
+	std::vector<SOM::InputVector> samples;
+	std::vector<Database::TrackId> samplesTrackIds;
+
+	samples.reserve(trackIds.size());
+	samplesTrackIds.reserve(trackIds.size());
+
+	LMS_LOG(RECOMMENDATION, DEBUG) << "Extracting features...";
+	for (Database::TrackId trackId : trackIds)
+	{
+		if (_loadCancelled)
+			return;
+
+		std::optional<FeatureValuesMap> featureValuesMap;
+
+		if (_featuresFetchFunc)
+			featureValuesMap = getTrackFeatureValues(_featuresFetchFunc, trackId, featureNames);
+		else
+			featureValuesMap = getTrackFeatureValuesFromDb(session, trackId, featureNames);
+
+		if (!featureValuesMap)
+			continue;
+
+		std::optional<SOM::InputVector> inputVector {convertFeatureValuesMapToInputVector(*featureValuesMap, nbDimensions)};
+		if (!inputVector)
+			continue;
+
+		samples.emplace_back(std::move(*inputVector));
+		samplesTrackIds.emplace_back(trackId);
+	}
+	LMS_LOG(RECOMMENDATION, DEBUG) << "Extracting features DONE";
+
+	if (samples.empty())
+	{
+		LMS_LOG(RECOMMENDATION, INFO) << "Nothing to classify!";
+		return;
+	}
+
+	LMS_LOG(RECOMMENDATION, DEBUG) << "Normalizing data...";
+	SOM::DataNormalizer dataNormalizer {nbDimensions};
+
+	dataNormalizer.computeNormalizationFactors(samples);
+	for (auto& sample : samples)
+		dataNormalizer.normalizeData(sample);
+
+	SOM::Coordinate size {static_cast<SOM::Coordinate>(std::sqrt(samples.size() / trainSettings.sampleCountPerNeuron))};
+	if (size < 2)
+	{
+		LMS_LOG(RECOMMENDATION, WARNING) << "Very few tracks (" << samples.size() << ") are being used by the features engine, expect bad behaviors";
+		size = 2;
+	}
+	LMS_LOG(RECOMMENDATION, INFO) << "Found " << samples.size() << " tracks, constructing a " << size << "*" << size << " network";
+
+	SOM::Network network {size, size, nbDimensions};
+
+	SOM::InputVector weights {getInputVectorWeights(trainSettings.featureSettingsMap, nbDimensions)};
+	network.setDataWeights(weights);
+
+	auto somProgressCallback{[&](const SOM::Network::CurrentIteration& iter)
+	{
+		LMS_LOG(RECOMMENDATION, DEBUG) << "Current pass = " << iter.idIteration << " / " << iter.iterationCount;
+		progressCallback(Progress {iter.idIteration, iter.iterationCount});
+	}};
+
+	LMS_LOG(RECOMMENDATION, DEBUG) << "Training network...";
+	network.train(samples, trainSettings.iterationCount,
+			progressCallback ? somProgressCallback : SOM::Network::ProgressCallback {},
+			[this] { return _loadCancelled; });
+	LMS_LOG(RECOMMENDATION, DEBUG) << "Training network DONE";
+
+
+	LMS_LOG(RECOMMENDATION, DEBUG) << "Classifying tracks...";
+	TrackPositions trackPositions;
+	for (std::size_t i {}; i < samples.size(); ++i)
+	{
+		if (_loadCancelled)
+			return;
+
+		const SOM::Position position {network.getClosestRefVectorPosition(samples[i])};
+
+		trackPositions[samplesTrackIds[i]].push_back(position);
+	}
+
+	LMS_LOG(RECOMMENDATION, DEBUG) << "Classifying tracks DONE";
+
+	load(std::move(network), std::move(trackPositions));
+}
+
+void
+FeaturesEngine::loadFromCache(FeaturesEngineCache cache)
+{
+	LMS_LOG(RECOMMENDATION, INFO) << "Constructing features classifier from cache...";
+
+	load(std::move(cache._network), cache._trackPositions);
+}
+
+IEngine::TrackContainer
+FeaturesEngine::getSimilarTracksFromTrackList(Database::TrackListId trackListId, std::size_t maxCount) const
+{
+	const TrackContainer trackIds {[&]
+	{
+		TrackContainer res;
+
+		Database::Session& session {_db.getTLSSession()};
+
+		auto transaction {session.createSharedTransaction()};
+
+		const Database::TrackList::pointer trackList {Database::TrackList::getById(session, trackListId)};
+		if (trackList)
+			res = trackList->getTrackIds();
+
+		return res;
+	}()};
+
+	return getSimilarTracks(trackIds, maxCount);
+}
+
+IEngine::TrackContainer
+FeaturesEngine::getSimilarTracks(const std::vector<Database::TrackId>& tracksIds, std::size_t maxCount) const
+{
+	auto similarTrackIds {getSimilarObjects(tracksIds, _trackMatrix, _trackPositions, maxCount)};
+
+	Database::Session& session {_db.getTLSSession()};
+
+	{
+		// Report only existing ids, as tracks may have been removed a long time ago (refreshing the SOM takes some time)
+		auto transaction {session.createSharedTransaction()};
+
+		similarTrackIds.erase(std::remove_if(std::begin(similarTrackIds), std::end(similarTrackIds),
+			[&](Database::TrackId trackId)
+			{
+				return !Database::Track::exists(session, trackId);
+			}), std::end(similarTrackIds));
+	}
+
+	return similarTrackIds;
+}
+
+IEngine::ReleaseContainer
+FeaturesEngine::getSimilarReleases(Database::ReleaseId releaseId, std::size_t maxCount) const
+{
+	auto similarReleaseIds {getSimilarObjects({releaseId}, _releaseMatrix, _releasePositions, maxCount)};
+
+	Database::Session& session {_db.getTLSSession()};
+
+	if (!similarReleaseIds.empty())
+	{
+		// Report only existing ids
+		auto transaction {session.createSharedTransaction()};
+
+		similarReleaseIds.erase(std::remove_if(std::begin(similarReleaseIds), std::end(similarReleaseIds),
+			[&](Database::ReleaseId releaseId)
+			{
+				return !Database::Release::exists(session, releaseId);
+			}), std::end(similarReleaseIds));
+	}
+
+	return similarReleaseIds;
+}
+
+std::vector<Database::ArtistId>
+FeaturesEngine::getSimilarArtists(Database::ArtistId artistId, EnumSet<Database::TrackArtistLinkType> linkTypes, std::size_t maxCount) const
+{
+	auto getSimilarArtistIdsForLinkType {[&] (Database::TrackArtistLinkType linkType)
+	{
+		std::vector<Database::ArtistId> similarArtistIds;
+
+		const auto itArtists {_artistMatrix.find(linkType)};
+		if (itArtists == std::cend(_artistMatrix))
+		{
+			return similarArtistIds;
+		}
+
+		return getSimilarObjects({artistId}, itArtists->second, _artistPositions, maxCount);
+	}};
+
+	std::unordered_set<Database::ArtistId> similarArtistIds;
+
+	for (Database::TrackArtistLinkType linkType : linkTypes)
+	{
+		const auto similarArtistIdsForLinkType {getSimilarArtistIdsForLinkType(linkType)};
+		similarArtistIds.insert(std::begin(similarArtistIdsForLinkType), std::end(similarArtistIdsForLinkType));
+	}
+
+	std::vector<Database::ArtistId> res(std::cbegin(similarArtistIds), std::cend(similarArtistIds));
+
+	Database::Session& session {_db.getTLSSession()};
+	{
+		// Report only existing ids
+		auto transaction {session.createSharedTransaction()};
+
+		res.erase(std::remove_if(std::begin(res), std::end(res),
+			[&](Database::ArtistId artistId)
+			{
+				return !Database::Artist::exists(session, artistId);
+			}), std::end(res));
+	}
+
+	while (res.size() > maxCount)
+		res.erase(Random::pickRandom(res));
+
+	return res;
+}
+
+FeaturesEngineCache
+FeaturesEngine::toCache() const
+{
+	return FeaturesEngineCache {*_network, _trackPositions};
+}
+
+void
+FeaturesEngine::load(bool forceReload, const ProgressCallback& progressCallback)
+{
+	if (forceReload)
+	{
+		FeaturesEngineCache::invalidate();
+	}
+	else if (const std::optional<FeaturesEngineCache> cache {FeaturesEngineCache::read()})
+	{
+		loadFromCache(*cache);
+		return;
+	}
+
+	TrainSettings trainSettings;
+	trainSettings.featureSettingsMap = getDefaultTrainFeatureSettings();
+
+	loadFromTraining(trainSettings, progressCallback);
+	if (!_loadCancelled)
+		toCache().write();
+}
+
+void
+FeaturesEngine::requestCancelLoad()
+{
+	LMS_LOG(RECOMMENDATION, DEBUG) << "Requesting init cancellation";
+	_loadCancelled = true;
+}
+
+void
+FeaturesEngine::load(const SOM::Network& network, const TrackPositions& trackPositions)
+{
+	using namespace Database;
+
+	_networkRefVectorsDistanceMedian = network.computeRefVectorsDistanceMedian();
+	LMS_LOG(RECOMMENDATION, DEBUG) << "Median distance betweend ref vectors = " << _networkRefVectorsDistanceMedian;
+
+	const SOM::Coordinate width {network.getWidth()};
+	const SOM::Coordinate height {network.getHeight()};
+
+	_releaseMatrix = ReleaseMatrix {width, height};
+	_trackMatrix = TrackMatrix {width, height};
+
+	LMS_LOG(RECOMMENDATION, DEBUG) << "Constructing maps...";
+
+	Database::Session& session {_db.getTLSSession()};
+
+	for (const auto& [trackId, positions] : trackPositions)
+	{
+		if (_loadCancelled)
+			return;
+
+		auto transaction {session.createSharedTransaction()};
+
+		const Track::pointer track {Database::Track::getById(session, trackId)};
+		if (!track)
+			continue;
+
+		for (const SOM::Position& position : positions)
+		{
+			Utils::push_back_if_not_present(_trackPositions[trackId], position);
+			Utils::push_back_if_not_present(_trackMatrix[position], trackId);
+
+			if (Release::pointer release {track->getRelease()})
+			{
+				const ReleaseId releaseId {release->getId()};
+				Utils::push_back_if_not_present(_releasePositions[releaseId], position);
+				Utils::push_back_if_not_present(_releaseMatrix[position], releaseId);
+			}
+			for (const TrackArtistLink::pointer& artistLink : track->getArtistLinks())
+			{
+				const ArtistId artistId {artistLink->getArtist()->getId()};
+
+				Utils::push_back_if_not_present(_artistPositions[artistId], position);
+				auto itArtists {_artistMatrix.find(artistLink->getType())};
+				if (itArtists == std::cend(_artistMatrix))
+				{
+					auto [it, inserted] = _artistMatrix.try_emplace(artistLink->getType(), ArtistMatrix {width, height});
+					assert(inserted);
+					itArtists = it;
+				}
+				Utils::push_back_if_not_present(itArtists->second[position], artistId);
+			}
+		}
+	}
+
+	_network = std::make_unique<SOM::Network>(network);
+
+	LMS_LOG(RECOMMENDATION, INFO) << "Classifier successfully loaded!";
+}
+
+} // ns Recommendation

src/libs/services/recommendation/impl/features/FeaturesEngine.hpp

@@ -0,0 +1,213 @@
+/*
+ * Copyright (C) 2018 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 <algorithm>
+#include <functional>
+#include <unordered_map>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "recommendation/IEngine.hpp"
+#include "som/DataNormalizer.hpp"
+#include "som/Network.hpp"
+#include "utils/Utils.hpp"
+#include "FeaturesEngineCache.hpp"
+#include "FeaturesDefs.hpp"
+
+namespace Database
+{
+	class Session;
+}
+
+namespace Recommendation {
+
+using FeatureWeight = double;
+
+class FeaturesEngine : public IEngine
+{
+	public:
+		FeaturesEngine(Database::Db& db) : _db {db} {}
+
+		FeaturesEngine(const FeaturesEngine&) = delete;
+		FeaturesEngine(FeaturesEngine&&) = delete;
+		FeaturesEngine& operator=(const FeaturesEngine&) = delete;
+		FeaturesEngine& operator=(FeaturesEngine&&) = delete;
+
+		using FeaturesFetchFunc = std::function<std::optional<std::unordered_map<std::string, std::vector<double>>>(Database::TrackId, const std::unordered_set<std::string>& /*features*/)>;
+		// Default is to retrieve the features from the database (may be slow).
+		// Use this only if you want to train different searchers with some cached data
+		static void setFeaturesFetchFunc(FeaturesFetchFunc func) { _featuresFetchFunc = func; }
+
+		static const FeatureSettingsMap& getDefaultTrainFeatureSettings();
+
+	private:
+		void load(bool forceReload, const ProgressCallback& progressCallback) override;
+		void requestCancelLoad() override;
+		void cancelLoad() override {}
+
+		TrackContainer getSimilarTracksFromTrackList(Database::TrackListId tracklistId, std::size_t maxCount) const override;
+		TrackContainer getSimilarTracks(const std::vector<Database::TrackId>& tracksId, std::size_t maxCount) const override;
+		ReleaseContainer getSimilarReleases(Database::ReleaseId releaseId, std::size_t maxCount) const override;
+		ArtistContainer getSimilarArtists(Database::ArtistId artistId, EnumSet<Database::TrackArtistLinkType> linkTypes, std::size_t maxCount) const override;
+
+		void loadFromCache(FeaturesEngineCache cache);
+
+		// Use training (may be very slow)
+		struct TrainSettings
+		{
+			std::size_t iterationCount {10};
+			float sampleCountPerNeuron {4};
+			FeatureSettingsMap featureSettingsMap;
+		};
+		void loadFromTraining(const TrainSettings& trainSettings, const ProgressCallback& progressCallback);
+
+		template <typename IdType>
+		using ObjectPositions = std::unordered_map<IdType, std::vector<SOM::Position>>;
+
+		using ArtistPositions = ObjectPositions<Database::ArtistId>;
+		using ReleasePositions = ObjectPositions<Database::ReleaseId>;
+		using TrackPositions = ObjectPositions<Database::TrackId>;
+
+		template <typename IdType>
+		using ObjectMatrix = SOM::Matrix<std::vector<IdType>>;
+		using ArtistMatrix = ObjectMatrix<Database::ArtistId>;
+		using ReleaseMatrix = ObjectMatrix<Database::ReleaseId>;
+		using TrackMatrix = ObjectMatrix<Database::TrackId>;
+
+		void load(const SOM::Network& network, const TrackPositions& tracksPosition);
+
+		FeaturesEngineCache toCache() const;
+
+		template <typename IdType>
+		static std::vector<SOM::Position> getMatchingRefVectorsPosition(const std::vector<IdType>& ids, const ObjectPositions<IdType>& objectPositions);
+
+		template <typename IdType>
+		static std::vector<IdType> getObjectsIds(const std::vector<SOM::Position>& positions, const ObjectMatrix<IdType>& objectsMatrix);
+
+		template <typename IdType>
+		std::vector<IdType> getSimilarObjects(const std::vector<IdType>& ids,
+				const ObjectMatrix<IdType>& objectMatrix,
+				const ObjectPositions<IdType>& objectPositions,
+				std::size_t maxCount) const;
+
+		Database::Db&		_db;
+		bool				_loadCancelled {};
+		std::unique_ptr<SOM::Network>	_network;
+		double				_networkRefVectorsDistanceMedian {};
+
+		ArtistPositions     _artistPositions;
+		std::unordered_map<Database::TrackArtistLinkType, ArtistMatrix> _artistMatrix;
+
+		ReleasePositions	_releasePositions;
+		ReleaseMatrix		_releaseMatrix;
+
+		TrackPositions		_trackPositions;
+		TrackMatrix			_trackMatrix;
+
+		static inline FeaturesFetchFunc _featuresFetchFunc;
+};
+
+template <typename IdType>
+std::vector<SOM::Position>
+FeaturesEngine::getMatchingRefVectorsPosition(const std::vector<IdType>& ids, const ObjectPositions<IdType>& objectPositions)
+{
+	std::vector<SOM::Position> res;
+
+	if (ids.empty())
+		return res;
+
+	for (const IdType id : ids)
+	{
+		auto it = objectPositions.find(id);
+		if (it == objectPositions.end())
+			continue;
+
+		for (const SOM::Position& position : it->second)
+			Utils::push_back_if_not_present(res, position);
+	}
+
+	return res;
+}
+
+template <typename IdType>
+std::vector<IdType>
+FeaturesEngine::getObjectsIds(const std::vector<SOM::Position>& positions, const ObjectMatrix<IdType>& objectMatrix)
+{
+	std::vector<IdType> res;
+
+	for (const SOM::Position& position : positions)
+	{
+		for (const IdType id : objectMatrix.get(position))
+			Utils::push_back_if_not_present(res, id);
+	}
+
+	return res;
+}
+
+template <typename IdType>
+std::vector<IdType>
+FeaturesEngine::getSimilarObjects(const std::vector<IdType>& ids,
+		const ObjectMatrix<IdType>& objectMatrix,
+		const ObjectPositions<IdType>& objectPositions,
+		std::size_t maxCount) const
+{
+	std::vector<IdType> res;
+
+	std::vector<SOM::Position> searchedRefVectorsPosition {getMatchingRefVectorsPosition(ids, objectPositions)};
+	if (searchedRefVectorsPosition.empty())
+		return res;
+
+	while (1)
+	{
+		std::vector<IdType> closestObjectIds {getObjectsIds(searchedRefVectorsPosition, objectMatrix)};
+
+		// Remove objects that are already in input or already reported
+		closestObjectIds.erase(std::remove_if(std::begin(closestObjectIds), std::end(closestObjectIds),
+					[&](IdType id)
+					{
+						return std::find(std::cbegin(ids), std::cend(ids), id) != std::cend(ids);
+					})
+				, std::end(closestObjectIds));
+
+		for (IdType id : closestObjectIds)
+		{
+			if (res.size() == maxCount)
+				break;
+
+			Utils::push_back_if_not_present(res, id);
+		}
+
+		if (res.size() == maxCount)
+			break;
+
+		// If there is not enough objects, try again with closest neighbour until there is too much distance
+		const std::optional<SOM::Position> closestRefVectorPosition {_network->getClosestRefVectorPosition(searchedRefVectorsPosition, _networkRefVectorsDistanceMedian * 0.75)};
+		if (!closestRefVectorPosition)
+			break;
+
+		Utils::push_back_if_not_present(searchedRefVectorsPosition, closestRefVectorPosition.value());
+	}
+
+	return res;
+}
+
+} // ns Recommendation

src/libs/services/recommendation/impl/features/FeaturesEngineCache.cpp

@@ -0,0 +1,255 @@
+/*
+ * Copyright (C) 2018 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 "FeaturesEngineCache.hpp"
+
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+
+#include "utils/IConfig.hpp"
+#include "utils/Logger.hpp"
+#include "utils/Service.hpp"
+
+namespace Recommendation {
+
+
+static
+std::filesystem::path getCacheDirectory()
+{
+	return Service<IConfig>::get()->getPath("working-dir") / "cache" / "features";
+}
+
+static std::filesystem::path getCacheNetworkFilePath()
+{
+	return getCacheDirectory() / "network";
+}
+
+static std::filesystem::path getCacheTrackPositionsFilePath()
+{
+	return getCacheDirectory() / "track_positions";
+}
+
+static
+bool
+networkToCacheFile(const SOM::Network& network, std::filesystem::path path)
+{
+	try
+	{
+		boost::property_tree::ptree root;
+
+		root.put("width", network.getWidth());
+		root.put("height", network.getHeight());
+		root.put("dim_count", network.getInputDimCount());
+
+		for (SOM::InputVector::value_type weight : network.getDataWeights())
+			root.add("weights.weight", weight);
+
+		for (SOM::Coordinate x = 0; x < network.getWidth(); ++x)
+		{
+			for (SOM::Coordinate y = 0; y < network.getWidth(); ++y)
+			{
+				const auto& refVector = network.getRefVector({x, y});
+
+				boost::property_tree::ptree node;
+				for (auto value : refVector)
+					node.add("values.value", value);
+
+				node.put("coord_x", x);
+				node.put("coord_y", y);
+
+				root.add_child("ref_vectors.ref_vector", node);
+			}
+		}
+
+		boost::property_tree::write_xml(path.string(), root);
+
+		LMS_LOG(RECOMMENDATION, DEBUG) << "Created network cache";
+		return true;
+	}
+	catch (boost::property_tree::ptree_error& error)
+	{
+		LMS_LOG(RECOMMENDATION, ERROR) << "Cannot create network cache: " << error.what();
+		return false;
+	}
+}
+
+std::optional<SOM::Network>
+FeaturesEngineCache::createNetworkFromCacheFile(const std::filesystem::path& path)
+{
+	if (!std::filesystem::exists(path))
+		return std::nullopt;
+
+	try
+	{
+		LMS_LOG(RECOMMENDATION, INFO) << "Reading network from cache...";
+
+		boost::property_tree::ptree root;
+
+		boost::property_tree::read_xml(path.string(), root);
+
+		SOM::Coordinate width {root.get<SOM::Coordinate>("width")};
+		SOM::Coordinate height {root.get<SOM::Coordinate>("height")};
+		std::size_t dimCount {root.get<std::size_t>("dim_count")};
+
+		SOM::Network res {width, height, dimCount};
+
+		{
+			SOM::InputVector weights {dimCount};
+			std::size_t i {};
+			for (const auto& val : root.get_child("weights"))
+				weights[i++] = val.second.get_value<double>();
+
+			res.setDataWeights(weights);
+		}
+
+		for (const auto& node : root.get_child("ref_vectors"))
+		{
+			SOM::Coordinate x {node.second.get<SOM::Coordinate>("coord_x")};
+			SOM::Coordinate y {node.second.get<SOM::Coordinate>("coord_y")};
+
+			SOM::InputVector refVector {dimCount};
+			std::size_t i {};
+			for (const auto& val : node.second.get_child("values"))
+				refVector[i++] = val.second.get_value<SOM::InputVector::value_type>();
+
+			res.setRefVector({x, y}, refVector);
+		}
+
+		LMS_LOG(RECOMMENDATION, INFO) << "Successfully read network from cache";
+
+		return res;
+	}
+	catch (boost::property_tree::ptree_error& error)
+	{
+		LMS_LOG(RECOMMENDATION, ERROR) << "Cannot read network cache: " << error.what();
+		return std::nullopt;
+	}
+}
+
+bool
+FeaturesEngineCache::objectPositionToCacheFile(const TrackPositions& trackPositions, const std::filesystem::path& path)
+{
+	try
+	{
+		boost::property_tree::ptree root;
+
+		for (const auto& [id, positions] : trackPositions)
+		{
+			boost::property_tree::ptree node;
+
+			node.put("id", id.getValue());
+
+			for (const SOM::Position& position : positions)
+			{
+				boost::property_tree::ptree positionNode;
+				positionNode.put("x", position.x);
+				positionNode.put("y", position.y);
+
+				node.add_child("position.position", positionNode);
+			}
+
+			root.add_child("objects.object", node);
+		}
+
+		boost::property_tree::write_xml(path.string(), root);
+		return true;
+	}
+	catch (boost::property_tree::ptree_error& error)
+	{
+		LMS_LOG(RECOMMENDATION, ERROR) << "Cannot cache object position: " << error.what();
+		return false;
+	}
+}
+
+std::optional<FeaturesEngineCache::TrackPositions>
+FeaturesEngineCache::createObjectPositionsFromCacheFile(const std::filesystem::path& path)
+{
+	try
+	{
+		LMS_LOG(RECOMMENDATION, INFO) << "Reading object position from cache...";
+
+		boost::property_tree::ptree root;
+
+		boost::property_tree::read_xml(path.string(), root);
+
+		TrackPositions res;
+
+		for (const auto& object : root.get_child("objects"))
+		{
+			const Database::TrackId id {object.second.get<Database::IdType::ValueType>("id")};
+			for (const auto& position : object.second.get_child("position"))
+			{
+				auto x = position.second.get<SOM::Coordinate>("x");
+				auto y = position.second.get<SOM::Coordinate>("y");
+
+				res[id].push_back({x, y});
+			}
+		}
+
+		LMS_LOG(RECOMMENDATION, INFO) << "Successfully read object position from cache";
+
+		return res;
+	}
+	catch (boost::property_tree::ptree_error& error)
+	{
+		LMS_LOG(RECOMMENDATION, ERROR) << "Cannot create object position from cache file: " << error.what();
+		return std::nullopt;
+	}
+}
+
+void
+FeaturesEngineCache::invalidate()
+{
+	std::filesystem::remove(getCacheNetworkFilePath());
+	std::filesystem::remove(getCacheTrackPositionsFilePath());
+}
+
+std::optional<FeaturesEngineCache>
+FeaturesEngineCache::read()
+{
+	auto network{createNetworkFromCacheFile(getCacheNetworkFilePath())};
+	if (!network)
+		return std::nullopt;
+
+	auto trackPositions{createObjectPositionsFromCacheFile(getCacheTrackPositionsFilePath())};
+	if (!trackPositions)
+		return std::nullopt;
+
+	return FeaturesEngineCache {std::move(*network), std::move(*trackPositions)};
+}
+
+void
+FeaturesEngineCache::write() const
+{
+	std::filesystem::create_directories(Service<IConfig>::get()->getPath("working-dir") / "cache" / "features");
+
+	if (!networkToCacheFile(_network, getCacheNetworkFilePath())
+		|| !objectPositionToCacheFile(_trackPositions, getCacheTrackPositionsFilePath()))
+	{
+		invalidate();
+	}
+}
+
+FeaturesEngineCache::FeaturesEngineCache(SOM::Network network, TrackPositions trackPositions)
+: _network {std::move(network)},
+_trackPositions {std::move(trackPositions)}
+{
+}
+
+} // namespace Recommendation

src/libs/services/recommendation/impl/features/FeaturesEngineCache.hpp

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2018 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 <filesystem>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "database/Types.hpp"
+#include "som/Network.hpp"
+
+namespace Recommendation {
+
+class FeaturesEngineCache
+{
+	public:
+		static void invalidate();
+
+		static std::optional<FeaturesEngineCache> read();
+		void write() const;
+
+	private:
+		using TrackPositions = std::unordered_map<Database::TrackId, std::vector<SOM::Position>>;
+
+		FeaturesEngineCache(SOM::Network network, TrackPositions trackPositions);
+
+		static std::optional<SOM::Network> createNetworkFromCacheFile(const std::filesystem::path& path);
+		static std::optional<TrackPositions> createObjectPositionsFromCacheFile(const std::filesystem::path& path);
+		static bool objectPositionToCacheFile(const TrackPositions& trackPositions, const std::filesystem::path& path);
+
+		friend class FeaturesEngine;
+
+		SOM::Network		_network;
+		TrackPositions		_trackPositions;
+};
+
+} // namespace Recommendation

src/libs/services/recommendation/include/recommendation/IEngine.hpp

@@ -0,0 +1,66 @@
+/*
+ * 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 <functional>
+#include <memory>
+#include <string_view>
+#include "database/Types.hpp"
+#include "utils/EnumSet.hpp"
+
+namespace Database
+{
+	class Db;
+}
+
+namespace Recommendation
+{
+	class IEngine
+	{
+		public:
+			virtual ~IEngine() = default;
+
+			struct Progress
+			{
+				std::size_t totalElems {};
+				std::size_t	processedElems {};
+			};
+			using ProgressCallback = std::function<void(const Progress&)>;
+			virtual void load(bool forceReload, const ProgressCallback& progressCallback = {}) = 0;
+			virtual void cancelLoad() = 0;  // wait for cancel done
+			virtual void requestCancelLoad() = 0;
+
+			template <typename IdType>
+			using ResultContainer = std::vector<IdType>;
+
+			using ArtistContainer = ResultContainer<Database::ArtistId>;
+			using ReleaseContainer = ResultContainer<Database::ReleaseId>;
+			using TrackContainer = ResultContainer<Database::TrackId>;
+
+			virtual TrackContainer getSimilarTracksFromTrackList(Database::TrackListId tracklistId, std::size_t maxCount) const = 0;
+			virtual TrackContainer getSimilarTracks(const std::vector<Database::TrackId>& tracksId, std::size_t maxCount) const = 0;
+			virtual ReleaseContainer getSimilarReleases(Database::ReleaseId releaseId, std::size_t maxCount) const = 0;
+			virtual ArtistContainer getSimilarArtists(Database::ArtistId artistId, EnumSet<Database::TrackArtistLinkType> linkTypes, std::size_t maxCount) const = 0;
+	};
+
+	std::unique_ptr<IEngine> createEngine(Database::Db& db);
+
+} // ns Recommendation
+

src/libs/services/scanner/CMakeLists.txt

@@ -0,0 +1,29 @@
+
+add_library(lmsscanner SHARED
+	impl/AcousticBrainzUtils.cpp
+	impl/Scanner.cpp
+	impl/ScannerStats.cpp
+	)
+
+target_include_directories(lmsscanner INTERFACE
+	include
+	)
+
+target_include_directories(lmsscanner PRIVATE
+	include
+	)
+
+target_link_libraries(lmsscanner PRIVATE
+	lmsdatabase
+	lmsmetadata
+	lmsrecommendation
+	lmsutils
+	)
+
+target_link_libraries(lmsscanner PUBLIC
+	std::filesystem
+	Wt::Wt
+	)
+
+install(TARGETS lmsscanner DESTINATION lib)
+

src/libs/services/scanner/impl/AcousticBrainzUtils.cpp

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2018 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 "AcousticBrainzUtils.hpp"
+
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/json_parser.hpp>
+
+#include <Wt/WIOService.h>
+#include <Wt/Http/Client.h>
+
+#include "utils/IConfig.hpp"
+#include "utils/Logger.hpp"
+#include "utils/Service.hpp"
+#include "utils/UUID.hpp"
+
+
+namespace AcousticBrainz
+{
+
+static
+std::string
+getJsonData(const UUID& mbid)
+{
+	static constexpr std::string_view defaultAPIURL {"https://acousticbrainz.org"};
+
+	const std::string url {std::string {Service<IConfig>::get()->getString("acousticbrainz-api-base-url", defaultAPIURL)} + "/api/v1/" + std::string {mbid.getAsString()} + "/low-level"};
+
+	boost::asio::io_service ioService;
+
+	Wt::Http::Client client {ioService};
+	client.setFollowRedirect(true);
+	client.setSslCertificateVerificationEnabled(true);
+	client.setMaximumResponseSize(256*1024);
+
+	if (!client.get(url))
+	{
+		LMS_LOG(DBUPDATER, ERROR) << "Cannot perform a GET request to url '" << url << "'";
+		return {};
+	}
+
+	std::string response;
+	client.done().connect([&](Wt::AsioWrapper::error_code ec, const Wt::Http::Message &msg)
+	{
+		if (ec)
+		{
+			LMS_LOG(DBUPDATER, ERROR) << "GET request to url '" << url << "' failed: " << ec.message();
+			return;
+		}
+
+		if (msg.status() != 200)
+		{
+			LMS_LOG(DBUPDATER, ERROR) << "GET request to url '" << url << "' failed: status = " << msg.status() << ", body = " << msg.body();
+			return;
+		}
+
+		response = msg.body();
+	});
+
+	ioService.run();
+
+	return response;
+}
+
+std::string
+extractLowLevelFeatures(const UUID& recordingMBID)
+{
+	return getJsonData(recordingMBID);
+}
+
+} // namespace Scanner::AcousticBrainz

src/libs/services/scanner/impl/AcousticBrainzUtils.hpp

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2018 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>
+
+class UUID;
+
+namespace AcousticBrainz
+{
+	std::string extractLowLevelFeatures(const UUID& recordingMBID);
+}
+

src/libs/services/scanner/impl/Scanner.hpp

@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2013 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 <shared_mutex>
+#include <optional>
+#include <unordered_set>
+
+#include <Wt/WDateTime.h>
+#include <Wt/WIOService.h>
+#include <Wt/WSignal.h>
+
+#include <boost/asio/system_timer.hpp>
+
+#include "database/Types.hpp"
+#include "database/ScanSettings.hpp"
+#include "database/Session.hpp"
+#include "metadata/IParser.hpp"
+#include "scanner/IScanner.hpp"
+#include "utils/Path.hpp"
+
+class UUID;
+
+namespace Recommendation
+{
+	class IEngine;
+}
+
+namespace Scanner {
+
+class Scanner : public IScanner
+{
+	public:
+		Scanner(Database::Db& db, Recommendation::IEngine& recommendationEngine);
+		~Scanner();
+
+		Scanner(const Scanner&) = delete;
+		Scanner(Scanner&&) = delete;
+		Scanner& operator=(const Scanner&) = delete;
+		Scanner& operator=(Scanner&&) = delete;
+
+		void requestReload() override;
+		void requestImmediateScan(bool force) override;
+
+		Status	getStatus() const override;
+		Events&	getEvents() override { return _events; }
+
+	private:
+		void start();
+		void stop();
+
+		// Job handling
+		void scheduleNextScan();
+		void scheduleScan(bool force, const Wt::WDateTime& dateTime = {});
+
+		void abortScan();
+
+		// Update database (scheduled callback)
+		void scan(bool force);
+
+		void scanMediaDirectory( const std::filesystem::path& mediaDirectory, bool forceScan, ScanStats& stats);
+		bool fetchTrackFeatures(Database::TrackId trackId, const UUID& MBID);
+		void fetchTrackFeatures(ScanStats& stats);
+
+		// Helpers
+		void refreshScanSettings();
+
+		void countAllFiles(ScanStats& stats);
+		void removeMissingTracks(ScanStats& stats);
+		void removeOrphanEntries();
+		void checkDuplicatedAudioFiles(ScanStats& stats);
+		void scanAudioFile(const std::filesystem::path& file, bool forceScan, ScanStats& stats);
+		void notifyInProgressIfNeeded(const ScanStepStats& stats);
+		void notifyInProgress(const ScanStepStats& stats);
+		void reloadSimilarityEngine(ScanStats& stats);
+
+		Recommendation::IEngine&				_recommendationEngine;
+
+		std::mutex								_controlMutex;
+		std::atomic<bool>						_abortScan {};
+		Wt::WIOService							_ioService;
+		boost::asio::system_timer				_scheduleTimer {_ioService};
+		Events									_events;
+		std::chrono::system_clock::time_point	_lastScanInProgressEmit {};
+		Database::Session						_dbSession;
+		std::unique_ptr<MetaData::IParser>		_metadataParser;
+
+		mutable std::shared_mutex			_statusMutex;
+		State								_curState {State::NotScheduled};
+		std::optional<ScanStats> 			_lastCompleteScanStats;
+		std::optional<ScanStepStats> 		_currentScanStepStats;
+		Wt::WDateTime						_nextScheduledScan;
+
+		// Current scan settings
+		std::size_t				_scanVersion {};
+		Wt::WTime				_startTime;
+		Database::ScanSettings::UpdatePeriod 	_updatePeriod {Database::ScanSettings::UpdatePeriod::Never};
+		std::unordered_set<std::filesystem::path>		_fileExtensions;
+		std::filesystem::path					_mediaDirectory;
+		Database::ScanSettings::RecommendationEngineType _recommendationEngineType;
+};
+
+} // Scanner
+

src/libs/services/scanner/impl/ScannerStats.cpp

@@ -0,0 +1,50 @@
+/*
+ * 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/>.
+ */
+
+#include "scanner/ScannerStats.hpp"
+
+namespace Scanner {
+
+ScanError::ScanError(const std::filesystem::path& _file, ScanErrorType _error, const std::string& _systemError)
+: file {_file},
+error {_error},
+systemError {_systemError}
+{
+}
+
+std::size_t
+ScanStats::nbFiles() const
+{
+	return skips + additions + updates;
+}
+
+std::size_t
+ScanStats::nbChanges() const
+{
+	return additions + deletions + updates;
+}
+
+unsigned
+ScanStepStats::progress() const
+{
+	return (processedElems / static_cast<float>(totalElems ? totalElems : 1)) * 100;
+}
+
+} // namespace Scanner
+

src/libs/services/scanner/include/scanner/IScanner.hpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2013 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 "ScannerEvents.hpp"
+#include "ScannerStats.hpp"
+
+namespace Database
+{
+	class Db;
+}
+
+namespace Recommendation
+{
+	class IEngine;
+}
+
+namespace Scanner
+{
+
+	class IScanner
+	{
+		public:
+			virtual ~IScanner() = default;
+
+			// Async requests
+			virtual void requestReload() = 0;
+			virtual void requestImmediateScan(bool force) = 0;
+
+			enum class State
+			{
+				NotScheduled,
+				Scheduled,
+				InProgress,
+			};
+
+			struct Status
+			{
+				State								currentState {State::NotScheduled};
+				Wt::WDateTime						nextScheduledScan;
+				std::optional<ScanStats>			lastCompleteScanStats;
+				std::optional<ScanStepStats> 		currentScanStepStats;
+			};
+
+			virtual Status getStatus() const = 0;
+
+			virtual Events& getEvents() = 0;
+	};
+
+	std::unique_ptr<IScanner> createScanner(Database::Db& db, Recommendation::IEngine& recommendationEngine);
+
+} // Scanner
+

src/libs/services/scanner/include/scanner/ScannerEvents.hpp

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2020 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 <Wt/WDateTime.h>
+#include <Wt/WSignal.h>
+
+#include "ScannerStats.hpp"
+
+namespace Scanner
+{
+
+	struct Events
+	{
+		// Called just after scan start
+		Wt::Signal<> 				scanStarted;
+
+		// Called just after scan complete (true if changes have been made)
+		Wt::Signal<ScanStats>		scanComplete;
+
+		// Called during scan in progress
+		Wt::Signal<ScanStepStats>	scanInProgress;
+
+		// Called after a schedule
+		Wt::Signal<Wt::WDateTime>	scanScheduled;
+	};
+
+} // ns Scanner
+

src/libs/services/scanner/include/scanner/ScannerStats.hpp

@@ -0,0 +1,107 @@
+/*
+ * 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 <Wt/WDateTime.h>
+
+#include <filesystem>
+#include <vector>
+
+#include "database/Types.hpp"
+
+namespace Scanner {
+
+	enum class ScanErrorType
+	{
+		CannotReadFile,		// cannot read file
+		CannotParseFile,	// cannot parse file
+		NoAudioTrack,		// no audio track found
+		BadDuration,		// bad duration
+	};
+
+	enum class DuplicateReason
+	{
+		SameHash,
+		SameMBID,
+	};
+
+	struct ScanError
+	{
+		std::filesystem::path	file;
+		ScanErrorType		error;
+		std::string		systemError;
+
+		ScanError(const std::filesystem::path& file, ScanErrorType error, const std::string& systemError = "");
+	};
+
+	struct ScanDuplicate
+	{
+		Database::TrackId	trackId;
+		DuplicateReason		reason;
+	};
+
+	enum class ScanProgressStep : unsigned
+	{
+		ChekingForMissingFiles = 0,
+		DiscoveringFiles,
+		ScanningFiles,
+		FetchingTrackFeatures,
+		ReloadingSimilarityEngine,
+	};
+	static inline constexpr unsigned ScanProgressStepCount {5};
+
+	// reduced scan stats
+	struct ScanStepStats
+	{
+		Wt::WDateTime   startTime;
+
+		ScanProgressStep currentStep;
+
+		std::size_t	totalElems {};
+		std::size_t	processedElems {};
+
+		unsigned		progress() const;
+	};
+
+	struct ScanStats
+	{
+		Wt::WDateTime	startTime;
+		Wt::WDateTime	stopTime;
+
+		std::size_t	filesScanned {};	// Total number of files scanned (estimated)
+
+		std::size_t	skips {};			// no change since last scan
+		std::size_t	scans {};			// actually scanned filed
+
+		std::size_t	additions {};		// added in DB
+		std::size_t	deletions {};		// removed from DB
+		std::size_t	updates {};			// updated file in DB
+
+		std::size_t	featuresFetched {};	// features fetched in DB
+
+		std::vector<ScanError>		errors;
+		std::vector<ScanDuplicate>	duplicates;
+
+		std::size_t	nbFiles() const;
+		std::size_t	nbChanges() const;
+	};
+
+}
+

src/libs/services/scrobbling/CMakeLists.txt

@@ -0,0 +1,28 @@
+
+add_library(lmsscrobbling SHARED
+	impl/internal/InternalScrobbler.cpp
+	impl/listenbrainz/ListenBrainzScrobbler.cpp
+	impl/listenbrainz/ListensSynchronizer.cpp
+	impl/listenbrainz/Utils.cpp
+	impl/ScrobblingService.cpp
+	)
+
+target_include_directories(lmsscrobbling INTERFACE
+	include
+	)
+
+target_include_directories(lmsscrobbling PRIVATE
+	include
+	impl
+	)
+
+target_link_libraries(lmsscrobbling PRIVATE
+	lmsutils
+	)
+
+target_link_libraries(lmsscrobbling PUBLIC
+	lmsdatabase
+	)
+
+install(TARGETS lmsscrobbling DESTINATION lib)
+

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

@@ -0,0 +1,56 @@
+/*
+ * 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 <Wt/WDateTime.h>
+
+#include "services/scrobbling/Listen.hpp"
+
+namespace Database
+{
+	class Session;
+	class TrackList;
+	class User;
+}
+
+namespace Scrobbling
+{
+
+	class IScrobbler
+	{
+		public:
+			virtual ~IScrobbler() = default;
+
+			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;
+	};
+
+	std::unique_ptr<IScrobbler> createScrobbler(std::string_view backendName);
+
+} // ns Scrobbling
+

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

@@ -0,0 +1,244 @@
+/*
+ * 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 "ScrobblingService.hpp"
+
+#include "database/Artist.hpp"
+#include "database/Db.hpp"
+#include "database/Release.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "database/TrackList.hpp"
+#include "database/User.hpp"
+
+#include "internal/InternalScrobbler.hpp"
+#include "listenbrainz/ListenBrainzScrobbler.hpp"
+
+namespace Scrobbling
+{
+	using namespace Database;
+
+	std::unique_ptr<IScrobblingService>
+	createScrobblingService(boost::asio::io_context& ioContext, Db& db)
+	{
+		return std::make_unique<ScrobblingService>(ioContext, db);
+	}
+
+	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));
+	}
+
+	void
+	ScrobblingService::listenStarted(const Listen& listen)
+	{
+		if (std::optional<Database::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)})
+			_scrobblers[*scrobbler]->listenFinished(listen, duration);
+	}
+
+	void
+	ScrobblingService::addTimedListen(const TimedListen& listen)
+	{
+		if (std::optional<Database::Scrobbler> scrobbler {getUserScrobbler(listen.userId)})
+			_scrobblers[*scrobbler]->addTimedListen(listen);
+	}
+
+	std::optional<Database::Scrobbler>
+	ScrobblingService::getUserScrobbler(Database::UserId userId)
+	{
+		std::optional<Database::Scrobbler> scrobbler;
+
+		Session& session {_db.getTLSSession()};
+		auto transaction {session.createSharedTransaction()};
+		if (const User::pointer user {User::getById(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)
+	{
+		ArtistContainer 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;
+	}
+
+	ScrobblingService::ReleaseContainer
+	ScrobblingService::getRecentReleases(Database::UserId userId,
+									const std::vector<Database::ClusterId>& clusterIds,
+									std::optional<Database::Range> range,
+									bool& moreResults)
+	{
+		ReleaseContainer 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;
+	}
+
+	ScrobblingService::TrackContainer
+	ScrobblingService::getRecentTracks(Database::UserId userId,
+										const std::vector<Database::ClusterId>& clusterIds,
+										std::optional<Database::Range> range,
+										bool& moreResults)
+	{
+		TrackContainer 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;
+	}
+
+
+	// 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)
+	{
+		ArtistContainer 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;
+	}
+
+	ScrobblingService::ReleaseContainer
+	ScrobblingService::getTopReleases(Database::UserId userId,
+								const std::vector<Database::ClusterId>& clusterIds,
+								std::optional<Database::Range> range,
+								bool& moreResults)
+	{
+		ReleaseContainer 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;
+	}
+
+	ScrobblingService::TrackContainer
+	ScrobblingService::getTopTracks(Database::UserId userId,
+								const std::vector<Database::ClusterId>& clusterIds,
+								std::optional<Database::Range> range,
+								bool& moreResults)
+	{
+		TrackContainer 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;
+	}
+
+	Database::ObjectPtr<Database::TrackList>
+	ScrobblingService::getListensTrackList(Session& session, Database::ObjectPtr<Database::User> user)
+	{
+		return _scrobblers[user->getScrobbler()]->getListensTrackList(session, user);
+	}
+
+} // ns Scrobbling
+

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

@@ -0,0 +1,82 @@
+/*
+ * 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 <optional>
+#include <unordered_map>
+
+#include "services/scrobbling/IScrobblingService.hpp"
+#include "IScrobbler.hpp"
+
+namespace Scrobbling
+{
+	class ScrobblingService : public IScrobblingService
+	{
+		public:
+			ScrobblingService(boost::asio::io_context& ioContext, 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;
+
+			ArtistContainer getRecentArtists(Database::UserId userId,
+												const std::vector<Database::ClusterId>& clusterIds,
+												std::optional<Database::TrackArtistLinkType> linkType,
+												std::optional<Database::Range> range,
+												bool& moreResults) override;
+
+			ReleaseContainer getRecentReleases(Database::UserId userId,
+												const std::vector<Database::ClusterId>& clusterIds,
+												std::optional<Database::Range> range,
+												bool& moreResults) override;
+
+			TrackContainer getRecentTracks(Database::UserId userId,
+												const std::vector<Database::ClusterId>& clusterIds,
+												std::optional<Database::Range> range,
+												bool& moreResults) 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;
+
+			ReleaseContainer getTopReleases(Database::UserId userId,
+												const std::vector<Database::ClusterId>& clusterIds,
+												std::optional<Database::Range> range,
+												bool& moreResults) override;
+
+			TrackContainer getTopTracks(Database::UserId userId,
+												const std::vector<Database::ClusterId>& clusterIds,
+												std::optional<Database::Range> range,
+												bool& moreResults) override;
+
+			Database::ObjectPtr<Database::TrackList> getListensTrackList(Database::Session& session, Database::ObjectPtr<Database::User> user);
+
+			std::optional<Database::Scrobbler> getUserScrobbler(Database::UserId userId);
+
+			Database::Db& _db;
+			std::unordered_map<Database::Scrobbler, std::unique_ptr<IScrobbler>> _scrobblers;
+	};
+
+} // ns Scrobbling
+

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

@@ -0,0 +1,82 @@
+/*
+ * 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 "database/Db.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "database/TrackList.hpp"
+#include "database/User.hpp"
+#include "utils/Logger.hpp"
+
+namespace Scrobbling
+{
+	static const std::string historyTracklistName {"__scrobbler_internal_history__"};
+
+	InternalScrobbler::InternalScrobbler(Database::Db& db)
+	: _db {db}
+	{}
+
+	void
+	InternalScrobbler::listenStarted(const Listen& /*listen*/)
+	{
+		// nothing to do
+	}
+
+	void
+	InternalScrobbler::listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration)
+	{
+		// 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()};
+
+		const Database::User::pointer user {Database::User::getById(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)};
+		if (!track)
+			return;
+
+		Database::TrackListEntry::create(session, track, getListensTrackList(session, user), 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

@@ -0,0 +1,47 @@
+/*
+ * 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 "IScrobbler.hpp"
+
+namespace Database
+{
+	class Db;
+}
+
+namespace Scrobbling
+{
+	class InternalScrobbler final : public IScrobbler
+	{
+		public:
+			InternalScrobbler(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::ObjectPtr<Database::TrackList> getListensTrackList(Database::Session& session, Database::ObjectPtr<Database::User> user) override;
+
+			Database::Db&	_db;
+	};
+} // Scrobbling
+

src/libs/services/scrobbling/impl/listenbrainz/FeedbackSynchronizer.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 <boost/asio/io_context.hpp>
+#include <boost/asio/io_context_strand.hpp>
+#include <boost/asio/steady_timer.hpp>
+#include <Wt/Dbo/Dbo.h>
+
+#include "SendQueue.hpp"
+
+namespace Database
+{
+	class Db;
+	class Session;
+	class User;
+}
+
+namespace Scrobbling::ListenBrainz
+{
+	class ListensSynchronizer
+	{
+		public:
+			FeedbackSynchronizer(boost::asio::io_context& ioContext, Database::Db& db, SendQueue& sendQueue);
+
+			// void updateFeedback(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 {};
+				std::optional<std::size_t> listenCount {};
+
+				// resetted at each fetch
+				std::string		listenBrainzUserName; // need to be resolved first
+				Wt::WDateTime	maxDateTime;
+				std::size_t		fetchedListenCount{};
+				std::size_t		matchedListenCount{};
+				std::size_t		importedListenCount{};
+			};
+
+			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);
+			std::optional<SendQueue::RequestData>	createValidateTokenRequestData(Database::UserId userId);
+			std::optional<SendQueue::RequestData>	createGetListensRequestData(std::string_view listenBrainzUserName, const Wt::WDateTime& maxDateTime);
+			void									processGetListensResponse(std::string_view body, UserContext& context);
+
+			boost::asio::io_context&		_ioContext;
+			boost::asio::io_context::strand	_strand {_ioContext};
+			Database::Db&					_db;
+			SendQueue&						_sendQueue;
+			boost::asio::steady_timer		_getListensTimer {_ioContext};
+
+			std::unordered_map<Database::UserId, UserContext> _userContexts;
+
+			const std::size_t			_maxSyncFeedbackCount;
+			const std::chrono::hours	_syncFeedbackPeriod;
+	};
+} // Scrobbling::ListenBrainz
+

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

@@ -0,0 +1,225 @@
+/*
+ * 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 <Wt/Json/Array.h>
+#include <Wt/Json/Object.h>
+#include <Wt/Json/Value.h>
+#include <Wt/Json/Serializer.h>
+
+#include "database/Artist.hpp"
+#include "database/Db.hpp"
+#include "database/Release.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "database/TrackList.hpp"
+#include "database/User.hpp"
+#include "utils/IConfig.hpp"
+#include "utils/http/IClient.hpp"
+#include "utils/Logger.hpp"
+#include "utils/Service.hpp"
+#include "Utils.hpp"
+
+#define LOG(sev)	LMS_LOG(SCROBBLING, sev) << "[listenbrainz] - "
+
+namespace
+{
+	bool
+	canBeScrobbled(Database::Session& session, Database::TrackId trackId, std::chrono::seconds duration)
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		const Database::Track::pointer track {Database::Track::getById(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;
+	}
+
+	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::getById(session, listen.trackId)};
+		if (!track)
+			return std::nullopt;
+
+		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;
+		}
+
+		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()}});
+			}
+
+			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->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)};
+
+		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())};
+
+		return payload;
+	}
+
+	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;
+
+		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;
+	}
+}
+
+namespace Scrobbling::ListenBrainz
+{
+	Scrobbler::Scrobbler(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")}
+		, _listensSynchronizer {_ioContext, db, _baseAPIUrl}
+	{
+		LOG(INFO) << "Starting ListenBrainz scrobbler... API endpoint = '" << _baseAPIUrl;
+	}
+
+	Scrobbler::~Scrobbler()
+	{
+		LOG(INFO) << "Stopped ListenBrainz scrobbler!";
+	}
+
+	void
+	Scrobbler::listenStarted(const Listen& listen)
+	{
+		enqueListen(listen, Wt::WDateTime {});
+	}
+
+	void
+	Scrobbler::listenFinished(const Listen& listen, std::optional<std::chrono::seconds> duration)
+	{
+		if (duration && !canBeScrobbled(_db.getTLSSession(), listen.trackId, *duration))
+			return;
+
+		const Listen timedListen {listen};
+		const Wt::WDateTime now {Wt::WDateTime::currentDateTime()};
+
+		enqueListen(timedListen, now);
+	}
+
+	void
+	Scrobbler::addTimedListen(const TimedListen& listen)
+	{
+		assert(listen.listenedAt.isValid());
+		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)
+	{
+		Http::ClientPOSTRequestParameters request;
+		request.url = _baseAPIUrl + "/1/submit-listens";
+
+		if (timePoint.isValid())
+		{
+			request.priority = Http::ClientRequestParameters::Priority::Normal;
+			request.onSuccessFunc = [=](std::string_view)
+			{
+				_listensSynchronizer.saveListen(TimedListen {listen, timePoint});
+			};
+		}
+		else
+		{
+			// We want "listen now" to appear as soon as possible
+			request.priority = Http::ClientRequestParameters::Priority::High;
+		}
+
+		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)
+			return;
+
+		request.message.addBodyText(bodyText);
+		request.message.addHeader("Authorization", "Token " + std::string {listenBrainzToken->getAsString()});
+		request.message.addHeader("Content-Type", "application/json");
+		Service<Http::IClient>::get()->sendPOSTRequest(std::move(request));
+	}
+} // namespace Scrobbling::ListenBrainz
+

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

@@ -0,0 +1,64 @@
+/*
+ * 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 <boost/asio/io_context.hpp>
+
+#include "IScrobbler.hpp"
+#include "ListensSynchronizer.hpp"
+
+namespace Database
+{
+	class Db;
+	class Session;
+	class TrackList;
+}
+
+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;
+			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;
+			std::string					_baseAPIUrl;
+			ListensSynchronizer			_listensSynchronizer;
+	};
+} // Scrobbling::ListenBrainz
+

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

@@ -0,0 +1,482 @@
+/*
+ * 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 <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 "database/Artist.hpp"
+#include "database/Db.hpp"
+#include "database/Release.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "database/TrackList.hpp"
+#include "database/User.hpp"
+#include "services/scrobbling/Exception.hpp"
+#include "utils/IConfig.hpp"
+#include "utils/http/IClient.hpp"
+#include "utils/Logger.hpp"
+#include "utils/Service.hpp"
+
+#include "Utils.hpp"
+
+#define LOG(sev)	LMS_LOG(SCROBBLING, sev) << "[listenbrainz Synchronizer] - "
+
+namespace
+{
+	using namespace Scrobbling::ListenBrainz;
+
+	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;
+	}
+
+	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;
+		}
+	}
+
+	Database::Track::pointer
+	tryMatchListen(Database::Session& session, const Wt::Json::Object& metadata)
+	{
+		Database::Track::pointer track;
+
+		// first try to get the associated track using MBIDs, and then fallback on names
+		if (metadata.type("additional_info") == Wt::Json::Type::Object)
+		{
+			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)};
+				// if duplicated files, do not record it (let the user correct its database)
+				if (tracks.size() == 1)
+					track = tracks.front();
+			}
+		}
+
+		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)
+		{
+			tracks.erase(std::remove_if(std::begin(tracks), std::end(tracks),
+				[&](const Database::Track::pointer track)
+				{
+					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; }))
+							return true;
+					}
+					if (metadata.type("additional_info") == Wt::Json::Type::Object)
+					{
+						const Wt::Json::Object& additionalInfo = metadata.get("additional_info");
+						if (track->getTrackNumber())
+						{
+							int otherTrackNumber {additionalInfo.get("tracknumber").orIfNull(-1)};
+							if (otherTrackNumber > 0 && static_cast<std::size_t>(otherTrackNumber) != *track->getTrackNumber())
+								return true;
+						}
+
+						if (auto releaseMBID {track->getRelease()->getMBID()})
+						{
+							if (std::optional<UUID> otherReleaseMBID {UUID::fromString(additionalInfo.get("release_mbid").orIfNull(""))})
+							{
+								if (otherReleaseMBID->getAsString() != releaseMBID->getAsString())
+									return true;
+							}
+						}
+					}
+
+					return false;
+				}), std::end(tracks));
+		}
+
+		if (tracks.size() == 1)
+			track = tracks.front();
+
+		return track;
+	}
+
+	struct ParseGetListensResult
+	{
+		Wt::WDateTime oldestEntry;
+		std::size_t listenCount{};
+		std::vector<Scrobbling::TimedListen> matchedListens;
+	};
+	ParseGetListensResult
+	parseGetListens(Database::Session& session, std::string_view msgBody, Database::UserId userId)
+	{
+		ParseGetListensResult result;
+
+		try
+		{
+			Wt::Json::Object root;
+			Wt::Json::parse(std::string {msgBody}, root);
+
+			const Wt::Json::Object& payload = root.get("payload");
+			const Wt::Json::Array& listens = payload.get("listens");
+
+			LOG(DEBUG) << "Got " << listens.size() << " listens";
+
+			if (listens.empty())
+				return result;
+
+			auto transaction {session.createSharedTransaction()};
+
+			for (const Wt::Json::Value& value : listens)
+			{
+				const Wt::Json::Object& listen = value;
+				const Wt::WDateTime listenedAt {Wt::WDateTime::fromTime_t(static_cast<int>(listen.get("listened_at")))};
+				const Wt::Json::Object& metadata = listen.get("track_metadata");
+
+				if (!listenedAt.isValid())
+				{
+					LOG(ERROR) << "bad listened_at field!";
+					continue;
+				}
+
+				result.listenCount++;
+				if (!result.oldestEntry.isValid())
+					result.oldestEntry = listenedAt;
+				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});
+			}
+		}
+		catch (const Wt::WException& error)
+		{
+			LOG(ERROR) << "Cannot parse 'get-listens' result: " << error.what();
+		}
+
+		return result;
+	}
+}
+
+namespace Scrobbling::ListenBrainz
+{
+	ListensSynchronizer::ListensSynchronizer(boost::asio::io_context& ioContext, Database::Db& db, std::string_view baseAPIUrl)
+		: _ioContext {ioContext}
+		, _db {db}
+		, _baseAPIUrl {baseAPIUrl}
+		, _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";
+
+		scheduleGetListens(std::chrono::seconds {30});
+	}
+
+	void
+	ListensSynchronizer::saveListen(const TimedListen& listen)
+	{
+		_strand.dispatch([=]
+		{
+			Database::Session& session {_db.getTLSSession()};
+
+			auto transaction {session.createUniqueTransaction()};
+
+			const Database::User::pointer user {Database::User::getById(session, listen.userId)};
+			if (!user)
+				return;
+
+			const Database::Track::pointer track {Database::Track::getById(session, listen.trackId)};
+			if (!track)
+				return;
+
+			Database::TrackListEntry::create(session, track, Utils::getOrCreateListensTrackList(session, user), listen.listenedAt);
+
+			UserContext& context {getUserContext(listen.userId)};
+			if (context.listenCount)
+				(*context.listenCount)++;
+		});
+	}
+
+	ListensSynchronizer::UserContext&
+	ListensSynchronizer::getUserContext(Database::UserId userId)
+	{
+		auto itContext {_userContexts.find(userId)};
+		if (itContext == std::cend(_userContexts))
+		{
+			auto [itNewContext, inserted] {_userContexts.emplace(userId, userId)};
+			itContext = itNewContext;
+		}
+
+		return itContext->second;
+	}
+
+	bool
+	ListensSynchronizer::isFetching() const
+	{
+		return std::any_of(std::cbegin(_userContexts), std::cend(_userContexts), [](const auto& contextEntry)
+				{
+					const auto& [userId, context] {contextEntry};
+					return context.fetching;
+				});
+	}
+
+	void
+	ListensSynchronizer::scheduleGetListens(std::chrono::seconds fromNow)
+	{
+		if (_syncListensPeriod.count() == 0 || _maxSyncListenCount == 0)
+			return;
+
+		LOG(DEBUG) << "Scheduled sync in " << fromNow.count() << " seconds...";
+		_getListensTimer.expires_after(fromNow);
+		_getListensTimer.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()} };
+			}
+
+			startGetListens();
+		}));
+	}
+
+	void
+	ListensSynchronizer::startGetListens()
+	{
+		LOG(DEBUG) << "GetListens started!!!";
+
+		assert(!isFetching());
+
+		std::vector<Database::UserId> userIds;
+		{
+			Database::Session& session {_db.getTLSSession()};
+			auto transaction {session.createSharedTransaction()};
+			userIds = Database::User::getAllIds(_db.getTLSSession());
+		}
+
+		for (const Database::UserId userId : userIds)
+		{
+			if (Utils::getListenBrainzToken(_db.getTLSSession(), userId))
+				startGetListens(getUserContext(userId));
+		}
+
+		if (!isFetching())
+			scheduleGetListens(_syncListensPeriod);
+	}
+
+	void
+	ListensSynchronizer::startGetListens(UserContext& context)
+	{
+		context.fetching = true;
+		context.listenBrainzUserName = "";
+		context.maxDateTime = {};
+		context.fetchedListenCount = 0;
+		context.matchedListenCount = 0;
+		context.importedListenCount = 0;
+
+		enqueValidateToken(context);
+	}
+
+	void
+	ListensSynchronizer::onGetListensEnded(UserContext& context)
+	{
+		_strand.dispatch([this, &context]
+		{
+			LOG(DEBUG) << "Fetch done for user " << context.userId.getValue() << ", fetched: " << context.fetchedListenCount << ", matched: " << context.matchedListenCount << ", imported: " << context.importedListenCount;
+			context.fetching = false;
+
+			if (!isFetching())
+				scheduleGetListens(_syncListensPeriod);
+		});
+	}
+
+	void
+	ListensSynchronizer::enqueValidateToken(UserContext& context)
+	{
+		assert(context.listenBrainzUserName.empty());
+
+		const std::optional<UUID> listenBrainzToken {Utils::getListenBrainzToken(_db.getTLSSession(), context.userId)};
+		if (!listenBrainzToken)
+		{
+			onGetListensEnded(context);
+			return;
+		}
+
+		Http::ClientGETRequestParameters request;
+		request.priority = Http::ClientRequestParameters::Priority::Low;
+		request.url = _baseAPIUrl + "/1/validate-token";
+		request.headers = { {"Authorization",  "Token " + std::string {listenBrainzToken->getAsString()}} };
+		request.onSuccessFunc = [this, &context] (std::string_view msgBody)
+			{
+				context.listenBrainzUserName = parseValidateToken(msgBody);
+				if (context.listenBrainzUserName.empty())
+				{
+					onGetListensEnded(context);
+					return;
+				}
+				enqueGetListenCount(context);
+			};
+		request.onFailureFunc = [this, &context]
+			{
+				onGetListensEnded(context);
+			};
+
+		Service<Http::IClient>::get()->sendGETRequest(std::move(request));
+	}
+
+	void
+	ListensSynchronizer::enqueGetListenCount(UserContext& context)
+	{
+		assert(!context.listenBrainzUserName.empty());
+
+		Http::ClientGETRequestParameters request;
+		request.url = _baseAPIUrl + "/1/user/" + std::string {context.listenBrainzUserName} + "/listen-count";
+		request.priority = Http::ClientRequestParameters::Priority::Low;
+		request.onSuccessFunc = [=, &context] (std::string_view msgBody)
+			{
+				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)
+				{
+					onGetListensEnded(context);
+					return;
+				}
+
+				context.maxDateTime = Wt::WDateTime::currentDateTime();
+				enqueGetListens(context);
+			};
+		request.onFailureFunc = [this, &context]
+			{
+				onGetListensEnded(context);
+			};
+
+		Service<Http::IClient>::get()->sendGETRequest(std::move(request));
+	}
+
+	void
+	ListensSynchronizer::enqueGetListens(UserContext& context)
+	{
+		assert(!context.listenBrainzUserName.empty());
+
+		Http::ClientGETRequestParameters request;
+		request.url = _baseAPIUrl + "/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())
+				{
+					onGetListensEnded(context);
+					return;
+				}
+
+				enqueGetListens(context);
+			};
+		request.onFailureFunc = [=, &context]
+			{
+				onGetListensEnded(context);
+			};
+
+		Service<Http::IClient>::get()->sendGETRequest(std::move(request));
+	}
+
+	void
+	ListensSynchronizer::processGetListensResponse(std::string_view msgBody, UserContext& context)
+	{
+		Database::Session& session {_db.getTLSSession()};
+
+		const ParseGetListensResult parseResult {parseGetListens(session, msgBody, context.userId)};
+
+		context.fetchedListenCount += parseResult.listenCount;
+		context.matchedListenCount += parseResult.matchedListens.size();
+		context.maxDateTime = parseResult.oldestEntry;
+
+		if (parseResult.matchedListens.empty())
+			return;
+
+		auto transaction {session.createUniqueTransaction()};
+
+		Database::User::pointer user {Database::User::getById(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)};
+			if (!track)
+				continue;
+
+			if (!tracklist->getEntryByTrackAndDateTime(track, listen.listenedAt))
+			{
+				context.importedListenCount++;
+				Database::TrackListEntry::create(session, track, tracklist, listen.listenedAt);
+			}
+		}
+	}
+
+} // namespace Scrobbling::ListenBrainz
+

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

@@ -0,0 +1,94 @@
+/*
+ * 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 <Wt/Dbo/Dbo.h>
+
+#include "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 {};
+				std::optional<std::size_t> listenCount {};
+
+				// resetted at each fetch
+				std::string		listenBrainzUserName; // need to be resolved first
+				Wt::WDateTime	maxDateTime;
+				std::size_t		fetchedListenCount{};
+				std::size_t		matchedListenCount{};
+				std::size_t		importedListenCount{};
+			};
+
+			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

@@ -0,0 +1,63 @@
+/*
+ * 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 <string_view>
+
+#include "database/Session.hpp"
+#include "database/TrackList.hpp"
+#include "database/User.hpp"
+
+static constexpr std::string_view historyTracklistName {"__scrobbler_listenbrainz_history__"};
+
+namespace Scrobbling::ListenBrainz::Utils
+{
+	std::optional<UUID>
+	getListenBrainzToken(Database::Session& session, Database::UserId userId)
+	{
+		auto transaction {session.createSharedTransaction()};
+
+		const Database::User::pointer user {Database::User::getById(session, userId)};
+		if (!user)
+			return std::nullopt;
+
+		if (user->getScrobbler() != Database::Scrobbler::ListenBrainz)
+			return std::nullopt;
+
+		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

@@ -0,0 +1,39 @@
+/*
+ * 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 <Wt/Dbo/ptr.h>
+#include "utils/UUID.hpp"
+
+#include "database/Types.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);
+}

src/libs/services/scrobbling/include/services/scrobbling/Exception.hpp

@@ -0,0 +1,32 @@
+/*
+ * 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 Scrobbling
+{
+
+	class Exception : public LmsException
+	{
+		public:
+			using LmsException::LmsException;
+	};
+}

src/libs/services/scrobbling/include/services/scrobbling/IScrobblingService.hpp

@@ -0,0 +1,103 @@
+/*
+ * 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 <boost/asio/io_service.hpp>
+
+#include <chrono>
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include <Wt/WDateTime.h>
+
+#include "services/scrobbling/Listen.hpp"
+#include "database/Types.hpp"
+
+namespace Database
+{
+	class Artist;
+	class Db;
+	class Release;
+	class Session;
+	class Track;
+	class User;
+}
+
+namespace Scrobbling
+{
+
+	class IScrobblingService
+	{
+		public:
+			virtual ~IScrobblingService() = default;
+
+			// Scrobbling
+			virtual void listenStarted(const Listen& listen) = 0;
+			virtual void listenFinished(const Listen& listen, std::optional<std::chrono::seconds> playedDuration = std::nullopt) = 0;
+
+			virtual void addTimedListen(const TimedListen& listen) = 0;
+
+			// Stats
+			template <typename IdType>
+			using ResultContainer = std::vector<IdType>;
+
+			using ArtistContainer = ResultContainer<Database::ArtistId>;
+			using ReleaseContainer = ResultContainer<Database::ReleaseId>;
+			using TrackContainer = ResultContainer<Database::TrackId>;
+			// From most recent to oldest
+			virtual ArtistContainer getRecentArtists(Database::UserId userId,
+														const std::vector<Database::ClusterId>& clusterIds,
+														std::optional<Database::TrackArtistLinkType> linkType,
+														std::optional<Database::Range> range,
+														bool& moreResults) = 0;
+
+			virtual ReleaseContainer getRecentReleases(Database::UserId userId,
+														const std::vector<Database::ClusterId>& clusterIds,
+														std::optional<Database::Range> range,
+														bool& moreResults) = 0;
+
+			virtual TrackContainer getRecentTracks(Database::UserId userId,
+														const std::vector<Database::ClusterId>& clusterIds,
+														std::optional<Database::Range> range,
+														bool& moreResults) = 0;
+
+			// Top
+			virtual ArtistContainer getTopArtists(Database::UserId userId,
+														const std::vector<Database::ClusterId>& clusterIds,
+														std::optional<Database::TrackArtistLinkType> linkType,
+														std::optional<Database::Range> range,
+														bool& moreResults) = 0;
+
+			virtual ReleaseContainer getTopReleases(Database::UserId userId,
+														const std::vector<Database::ClusterId>& clusterIds,
+														std::optional<Database::Range> range,
+														bool& moreResults) = 0;
+
+			virtual TrackContainer getTopTracks(Database::UserId userId,
+														const std::vector<Database::ClusterId>& clusterIds,
+														std::optional<Database::Range> range,
+														bool& moreResults) = 0;
+	};
+
+	std::unique_ptr<IScrobblingService> createScrobblingService(boost::asio::io_service& ioService, Database::Db& db);
+
+} // ns Scrobbling
+

src/libs/services/scrobbling/include/services/scrobbling/Listen.hpp

@@ -0,0 +1,39 @@
+/*
+ * 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 <Wt/WDateTime.h>
+
+#include "database/Types.hpp"
+
+namespace Scrobbling
+{
+	struct Listen
+	{
+		Database::UserId userId {};
+		Database::TrackId trackId {};
+	};
+
+	struct TimedListen : public Listen
+	{
+		Wt::WDateTime listenedAt;
+	};
+} // ns Scrobbling
+