WIP

src/liblms/include/api/subsonic/SubsonicResource.hpp

@@ -0,0 +1,47 @@
+/*
+ * 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/WResource.h>
+#include <Wt/Http/Response.h>
+
+#include "database/SessionPool.hpp"
+
+namespace Database
+{
+	class Db;
+}
+
+namespace API::Subsonic
+{
+
+class SubsonicResource final : public Wt::WResource
+{
+	public:
+		SubsonicResource(Database::Db& db);
+
+		static std::string getPath() { return "/rest/"; }
+	private:
+
+		void handleRequest(const Wt::Http::Request &request, Wt::Http::Response &response) override;
+
+		Database::SessionPool _sessionPool;
+};
+
+} // namespace

src/liblms/include/auth/IAuthTokenService.hpp

@@ -0,0 +1,71 @@
+/*
+ * 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 <boost/asio/ip/address.hpp>
+#include <Wt/WDateTime.h>
+
+#include "database/Types.hpp"
+
+namespace Database
+{
+	class Session;
+}
+
+
+namespace Auth {
+
+	class IAuthTokenService
+	{
+		public:
+
+			// Auth Token services
+			struct AuthTokenProcessResult
+			{
+				enum class State
+				{
+					Found,
+					Throttled,
+					NotFound,
+				};
+
+				struct AuthTokenInfo
+				{
+					Database::IdType userId;
+					Wt::WDateTime expiry;
+				};
+
+				State state {State::NotFound};
+				std::optional<AuthTokenInfo>	authTokenInfo {};
+			};
+
+			// Removed if found
+			virtual AuthTokenProcessResult	processAuthToken(Database::Session& session, const boost::asio::ip::address& clientAddress, const std::string& tokenValue) = 0;
+			virtual std::string		createAuthToken(Database::Session& session, Database::IdType userid, const Wt::WDateTime& expiry) = 0;
+	};
+
+	std::unique_ptr<IAuthTokenService> createAuthTokenService(std::size_t maxThrottlerEntryCount);
+
+}
+

src/liblms/include/auth/IPasswordService.hpp

@@ -0,0 +1,59 @@
+/*
+ * 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 <boost/asio/ip/address.hpp>
+
+#include "database/User.hpp"
+#include "database/Types.hpp"
+
+namespace Database
+{
+	class Session;
+}
+
+
+namespace Auth {
+
+	class IPasswordService
+	{
+		public:
+
+			virtual ~IPasswordService() = default;
+
+			// Password services
+			enum class PasswordCheckResult
+			{
+				Match,
+				Mismatch,
+				Throttled,
+			};
+			virtual PasswordCheckResult	checkUserPassword(Database::Session& session, const boost::asio::ip::address& clientAddress, const std::string& loginName, const std::string& password) = 0;
+			virtual Database::User::PasswordHash	hashPassword(const std::string& password) const = 0;
+			virtual bool				evaluatePasswordStrength(const std::string& loginName, const std::string& password) const = 0;
+	};
+
+	std::unique_ptr<IPasswordService> createPasswordService(std::size_t maxThrottlerEntryCount);
+
+}
+

src/liblms/include/av/AvInfo.hpp

@@ -0,0 +1,103 @@
+/*
+ * 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/>.
+ */
+
+/* This file contains some classes in order to get info from file using the libavconv */
+
+#pragma once
+
+extern "C"
+{
+#define __STDC_CONSTANT_MACROS
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/error.h>
+}
+
+#include <chrono>
+#include <filesystem>
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "AvTypes.hpp"
+
+namespace Av
+{
+
+void AvInit();
+
+struct Picture
+{
+	std::string mimeType;
+	std::vector<uint8_t> data;
+};
+
+struct StreamInfo
+{
+	size_t		id;
+	std::size_t     bitrate;
+};
+
+class MediaFileException : public AvException
+{
+	public:
+		MediaFileException(int avError);
+};
+
+class MediaFile
+{
+	public:
+		MediaFile(const std::filesystem::path& p);
+		~MediaFile();
+
+		MediaFile(const MediaFile&) = delete;
+		MediaFile& operator=(const MediaFile&) = delete;
+		MediaFile(MediaFile&&) = delete;
+		MediaFile& operator=(MediaFile&&) = delete;
+
+		std::string		getFormatName() const;
+
+		const std::filesystem::path&		getPath() const {return _p;};
+
+		std::chrono::milliseconds		getDuration() const;
+		std::map<std::string, std::string>	getMetaData(void);
+
+		std::vector<StreamInfo>	getStreamInfo() const;
+		std::optional<std::size_t>	getBestStream() const; // none if failure/unknown
+		bool			hasAttachedPictures(void) const;
+		std::vector<Picture>	getAttachedPictures(std::size_t nbMaxPictures) const;
+
+	private:
+
+		std::filesystem::path	_p;
+		AVFormatContext* _context {};
+};
+
+
+struct MediaFileFormat
+{
+	std::string mimeType;
+	std::string format;
+};
+
+std::optional<MediaFileFormat> guessMediaFileFormat(const std::filesystem::path& file);
+
+} // namespace Av
+

src/liblms/include/av/AvTranscoder.hpp

@@ -0,0 +1,76 @@
+/*
+ * 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 <chrono>
+#include <filesystem>
+#include <optional>
+
+#include <pstreams/pstream.h>
+
+#include "AvTypes.hpp"
+
+namespace Av {
+
+
+
+struct TranscodeParameters
+{
+	std::optional<Encoding>			encoding; // If not set, no transcoding is performed
+	std::size_t				bitrate {128000};
+	std::optional<std::size_t>		stream; // Id of the stream to be transcoded (auto detect by default)
+	std::optional<std::chrono::seconds>	offset;
+	bool 					stripMetadata {true};
+};
+
+class Transcoder
+{
+	public:
+		static void init();
+
+		Transcoder(const std::filesystem::path& file, const TranscodeParameters& parameters);
+		~Transcoder();
+
+		Transcoder(const Transcoder&) = delete;
+		Transcoder& operator=(const Transcoder&) = delete;
+		Transcoder(Transcoder&&) = delete;
+		Transcoder& operator=(Transcoder&&) = delete;
+
+		bool			start();
+		const std::string&	getOutputMimeType() const { return _outputMimeType; }
+		void			process(std::vector<unsigned char>& output, std::size_t maxSize);
+		bool			isComplete(void) const { return _isComplete; }
+
+		const TranscodeParameters& getParameters() const { return _parameters; }
+
+	private:
+		const std::filesystem::path	_filePath;
+		const TranscodeParameters	_parameters;
+
+		std::shared_ptr<redi::ipstream>	_child;
+
+		bool			_isComplete {};
+		std::size_t		_total {};
+		const std::size_t	_id {};
+		std::string		_outputMimeType;
+};
+
+} // namespace Av
+

src/liblms/include/av/AvTypes.hpp

@@ -0,0 +1,47 @@
+/*
+ * 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 "utils/Exception.hpp"
+
+namespace Av {
+
+class AvException : public LmsException
+{
+	public:
+		AvException(const std::string& msg) : LmsException(msg) {}
+};
+
+enum class Encoding
+{
+	// Values are important and must not be changed
+	MP3,
+	OGG_OPUS,
+	MATROSKA_OPUS,
+	OGG_VORBIS,
+	WEBM_VORBIS,
+};
+
+const char* encodingToMimetype(Encoding encoding);
+
+}
+

src/liblms/include/cover/CoverArt.hpp

@@ -0,0 +1,40 @@
+
+/*
+ * 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 <string>
+
+namespace CoverArt
+{
+
+	enum class Format
+	{
+		JPEG,
+	};
+	std::string formatToMimeType(Format format);
+
+	struct Geometry
+	{
+		std::size_t width;
+		std::size_t height;
+	};
+
+}

src/liblms/include/cover/ICoverArtGrabber.hpp

@@ -0,0 +1,47 @@
+/*
+ * 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 <filesystem>
+#include <vector>
+
+#include "database/Types.hpp"
+#include "cover/CoverArt.hpp"
+
+namespace Database {
+	class Session;
+}
+
+namespace CoverArt {
+
+class IGrabber
+{
+	public:
+		virtual ~IGrabber() = default;
+
+		virtual void			setDefaultCover(const std::filesystem::path& defaultCoverPath) = 0;
+
+		virtual std::vector<uint8_t>	getFromTrack(Database::Session& dbSession, Database::IdType trackId, Format format, std::size_t width) = 0;
+		virtual std::vector<uint8_t>	getFromRelease(Database::Session& dbSession, Database::IdType releaseId, Format format, std::size_t width) = 0;
+
+};
+
+} // namespace CoverArt
+

src/liblms/include/database/Artist.hpp

@@ -0,0 +1,118 @@
+/*
+ * 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 <vector>
+
+#include <Wt/WDateTime.h>
+#include <Wt/Dbo/Dbo.h>
+
+#include "utils/UUID.hpp"
+
+#include "TrackArtistLink.hpp"
+#include "Types.hpp"
+
+namespace Database
+{
+
+class Cluster;
+class ClusterType;
+class Release;
+class Session;
+class Track;
+class User;
+
+class Artist : public Wt::Dbo::Dbo<Artist>
+{
+	public:
+
+		using pointer = Wt::Dbo::ptr<Artist>;
+
+		Artist() {}
+		Artist(const std::string& name, const std::optional<UUID>& MBID = {});
+
+		// Accessors
+		static pointer			getByMBID(Session& session, const UUID& MBID);
+		static pointer			getById(Session& session, IdType id);
+		static std::vector<pointer>	getByName(Session& session, const std::string& name);
+		static std::vector<pointer> 	getByClusters(Session& session,
+								const std::set<IdType>& clusters);		// at least one track that belongs to  these clusters
+		static std::vector<pointer> 	getByFilter(Session& session,
+								const std::set<IdType>& clusters,		// if non empty, at least one artist that belongs to these clusters
+								const std::vector<std::string>& keywords,	// if non empty, name must match all of these keywords
+								std::optional<TrackArtistLink::Type> linkType, 	// if set, only artists that have produced at least one track with this link type
+								std::optional<std::size_t> offset,
+								std::optional<std::size_t> size,
+								bool& moreExpected);
+
+		static std::vector<pointer>	getAll(Session& session, std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {});
+		static std::vector<IdType>	getAllIds(Session& session);
+		static std::vector<pointer>	getAllOrphans(Session& session); // No track related
+		static std::vector<pointer>	getLastAdded(Session& session, Wt::WDateTime after, std::optional<std::size_t> size = {});
+
+		// Accessors
+		const std::string& getName(void) const { return _name; }
+		std::optional<UUID> getMBID(void) const { return UUID::fromString(_MBID); }
+
+		std::vector<Wt::Dbo::ptr<Release>>	getReleases(const std::set<IdType>& clusterIds = {}) const; // if non empty, get the releases that match all these clusters
+		std::size_t				getReleaseCount() const;
+		std::vector<Wt::Dbo::ptr<Track>>	getTracks(std::optional<TrackArtistLink::Type> linkType = {}) const;
+		std::vector<Wt::Dbo::ptr<Track>>	getTracksWithRelease(std::optional<TrackArtistLink::Type> linkType = {}) const;
+		std::vector<Wt::Dbo::ptr<Track>>	getRandomTracks(std::optional<std::size_t> count) const;
+		std::vector<pointer>			getSimilarArtists(std::optional<std::size_t> offset = {}, std::optional<std::size_t> count = {}) 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<Wt::Dbo::ptr<Cluster>>> getClusterGroups(std::vector<Wt::Dbo::ptr<ClusterType>> clusterTypes, std::size_t size) const;
+
+		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, _name, "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/liblms/include/database/Cluster.hpp

@@ -0,0 +1,124 @@
+/*
+ * 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 <vector>
+
+#include <Wt/Dbo/Dbo.h>
+
+#include <Wt/WDateTime.h>
+
+#include "Types.hpp"
+
+namespace Database {
+
+class Track;
+class ClusterType;
+class ScanSettings;
+class Session;
+
+class Cluster : public Wt::Dbo::Dbo<Cluster>
+{
+	public:
+		using pointer = Wt::Dbo::ptr<Cluster>;
+
+		Cluster();
+		Cluster(Wt::Dbo::ptr<ClusterType> type, std::string name);
+
+		// Find utility
+		static std::vector<pointer> getAll(Session& session);
+		static std::vector<pointer> getAllOrphans(Session& session);
+		static pointer getById(Session& session, IdType id);
+
+		// Create utility
+		static pointer create(Session& session, Wt::Dbo::ptr<ClusterType> type, std::string name);
+
+		// Accessors
+		const std::string& getName() const		{ return _name; }
+		Wt::Dbo::ptr<ClusterType> getType() const	{ return _clusterType; }
+		std::size_t getTracksCount() const		{ return _tracks.size(); }
+		std::vector<Wt::Dbo::ptr<Track>> getTracks(std::optional<std::size_t> offset = {}, std::optional<std::size_t> limit = {}) const;
+		std::set<IdType> getTrackIds() const;
+		std::size_t getReleasesCount() const;
+
+		void addTrack(Wt::Dbo::ptr<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 Wt::Dbo::Dbo<ClusterType>
+{
+	public:
+
+		using pointer = Wt::Dbo::ptr<ClusterType>;
+
+		ClusterType() {}
+		ClusterType(std::string name);
+
+		static std::vector<pointer> getAllOrphans(Session& session);
+		static pointer getByName(Session& session, const std::string& name);
+		static pointer getById(Session& session, IdType 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/liblms/include/database/Db.hpp

@@ -0,0 +1,48 @@
+/*
+ * 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 <shared_mutex>
+
+#include <Wt/Dbo/SqlConnectionPool.h>
+
+namespace Database {
+
+// Session living class handling the database and the login
+class Db
+{
+	public:
+
+		Db(const std::filesystem::path& dbPath);
+
+	private:
+		friend class Session;
+
+		std::shared_mutex&		getMutex() { return _sharedMutex; }
+		Wt::Dbo::SqlConnectionPool&	getConnectionPool() { return *_connectionPool; }
+
+		std::shared_mutex				_sharedMutex;
+		std::unique_ptr<Wt::Dbo::SqlConnectionPool>	_connectionPool;
+};
+
+} // namespace Database
+
+

src/liblms/include/database/Release.hpp

@@ -0,0 +1,131 @@
+/*
+ * 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 <Wt/Dbo/WtSqlTraits.h>
+
+#include "utils/UUID.hpp"
+#include "TrackArtistLink.hpp"
+#include "Types.hpp"
+
+namespace Database
+{
+
+class Artist;
+class Cluster;
+class ClusterType;
+class Release;
+class Track;
+class User;
+
+class Release : public Wt::Dbo::Dbo<Release>
+{
+	public:
+
+		using pointer = Wt::Dbo::ptr<Release>;
+
+		Release() {}
+		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, IdType id);
+		static std::vector<pointer>	getAllOrphans(Session& session); // no track related
+		static std::vector<pointer>	getAll(Session& session, std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {});
+		static std::vector<IdType>	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, std::optional<std::size_t> size = {});
+		static std::vector<pointer>	getLastAdded(Session& session, const Wt::WDateTime& after, std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {});
+		static std::vector<pointer>	getByYear(Session& session, int yearFrom, int yearTo, std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {});
+
+		static std::vector<pointer>	getByClusters(Session& session, const std::set<IdType>& clusters);
+		static std::vector<pointer>	getByFilter(Session& session,
+							const std::set<IdType>& clusters,		// if non empty, at least one release that belongs to these clusters
+							const std::vector<std::string>& keywords,	// if non empty, name must match all of these keywords
+							std::optional<std::size_t> offset,
+							std::optional<std::size_t> size,
+							bool& moreExpected);
+
+		std::vector<Wt::Dbo::ptr<Track>> getTracks(const std::set<IdType>& clusters = std::set<IdType>()) const;
+		std::size_t			getTracksCount() 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<Wt::Dbo::ptr<Cluster>>> getClusterGroups(std::vector<Wt::Dbo::ptr<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; // 0 if unknown or various
+		std::optional<std::string> getCopyright() const;
+		std::optional<std::string> getCopyrightURL() const;
+
+		// Modifiers
+		void setTotalDiscNumber(std::size_t num)	{ _totalDiscNumber = static_cast<int>(num); }
+		void setTotalTrackNumber(std::size_t num)	{ _totalTrackNumber = static_cast<int>(num); }
+
+		// Accessors
+		std::string			getName() const		{ return _name; }
+		std::optional<UUID>		getMBID() const		{ return UUID::fromString(_MBID); }
+		std::optional<std::size_t>	getTotalTrackNumber() const;
+		std::optional<std::size_t>	getTotalDiscNumber() const;
+		std::chrono::milliseconds	getDuration() const;
+
+		// Get the artists of this release
+		std::vector<Wt::Dbo::ptr<Artist> > getArtists(TrackArtistLink::Type type = TrackArtistLink::Type::Artist) const;
+		std::vector<Wt::Dbo::ptr<Artist> > getReleaseArtists() const { return getArtists(TrackArtistLink::Type::ReleaseArtist); }
+		bool hasVariousArtists() const;
+		std::vector<pointer>		getSimilarReleases(std::optional<std::size_t> offset = {}, std::optional<std::size_t> count = {}) const;
+
+		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::field(a, _totalDiscNumber,	"total_disc_number");
+				Wt::Dbo::field(a, _totalTrackNumber,	"total_track_number");
+
+				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;
+		int		_totalDiscNumber {};
+		int		_totalTrackNumber {};
+
+		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/liblms/include/database/ScanSettings.hpp

@@ -0,0 +1,99 @@
+/*
+ * 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 <Wt/Dbo/Dbo.h>
+#include <Wt/WTime.h>
+
+namespace Database {
+
+class ClusterType;
+class Session;
+
+class ScanSettings : public Wt::Dbo::Dbo<ScanSettings>
+{
+	public:
+		using pointer = Wt::Dbo::ptr<ScanSettings>;
+
+		// Do not modify values (just add)
+		enum class UpdatePeriod {
+			Never = 0,
+			Daily,
+			Weekly,
+			Monthly
+		};
+
+		// Do not modify values (just add)
+		enum class SimilarityEngineType
+		{
+			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<Wt::Dbo::ptr<ClusterType>> getClusterTypes() const;
+		std::set<std::filesystem::path> getAudioFileExtensions() const;
+		SimilarityEngineType getSimilarityEngineType() const { return _similarityEngineType; }
+
+		// Setters
+		void addAudioFileExtension(const std::filesystem::path& ext);
+		void setMediaDirectory(const std::filesystem::path& p);
+		void setUpdateStartTime(Wt::WTime t) { _startTime = t; }
+		void setUpdatePeriod(UpdatePeriod p) { _updatePeriod = p; }
+		void setClusterTypes(Session& session, const std::set<std::string>& clusterTypeNames);
+		void setSimilarityEngineType(SimilarityEngineType type) { _similarityEngineType = type; }
+		void incScanVersion();
+
+		template<class Action>
+		void persist(Action& a)
+		{
+			Wt::Dbo::field(a, _scanVersion,		"scan_version");
+			Wt::Dbo::field(a, _mediaDirectory,	"media_directory");
+			Wt::Dbo::field(a, _startTime,		"start_time");
+			Wt::Dbo::field(a, _updatePeriod,	"update_period");
+			Wt::Dbo::field(a, _audioFileExtensions,	"audio_file_extensions");
+			Wt::Dbo::field(a, _similarityEngineType,"similarity_engine_type");
+			Wt::Dbo::hasMany(a, _clusterTypes, Wt::Dbo::ManyToOne, "scan_settings");
+		}
+
+	private:
+
+		int		_scanVersion {};
+		std::string	_mediaDirectory;
+		Wt::WTime	_startTime = Wt::WTime {0,0,0};
+		UpdatePeriod	_updatePeriod {UpdatePeriod::Never};
+		SimilarityEngineType _similarityEngineType {SimilarityEngineType::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/liblms/include/database/Session.hpp

@@ -0,0 +1,93 @@
+/*
+ * 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 <mutex>
+#include <map>
+#include <memory>
+#include <shared_mutex>
+#include <vector>
+
+#include <Wt/Dbo/Dbo.h>
+#include <Wt/Dbo/SqlConnectionPool.h>
+
+namespace Database {
+
+class UniqueTransaction
+{
+	public:
+		~UniqueTransaction();
+
+	private:
+		friend class Session;
+		UniqueTransaction(std::shared_mutex& mutex, Wt::Dbo::Session& session);
+
+		std::unique_lock<std::shared_mutex> _lock;
+		Wt::Dbo::Transaction _transaction;
+};
+
+class SharedTransaction
+{
+	public:
+		~SharedTransaction();
+
+	private:
+		friend class Session;
+		SharedTransaction(std::shared_mutex& mutex, Wt::Dbo::Session& session);
+
+		std::shared_lock<std::shared_mutex> _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/liblms/include/database/SessionPool.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 <memory>
+#include <mutex>
+#include <vector>
+
+#include "Session.hpp"
+
+namespace Database {
+
+class SessionPool
+{
+	public:
+		class ScopedSession
+		{
+			public:
+				ScopedSession(SessionPool& pool) : _pool {pool}, _session {_pool.acquireSession()} {}
+				~ScopedSession() { _pool.releaseSession(_session); }
+
+				ScopedSession(const ScopedSession&) = delete;
+				ScopedSession(ScopedSession&&) = delete;
+				ScopedSession& operator=(const ScopedSession&) = delete;
+				ScopedSession& operator=(ScopedSession&&) = delete;
+
+				Session& get() { return _session; }
+
+			private:
+				SessionPool& _pool;
+				Session& _session;
+		};
+
+		SessionPool(Db& database, std::size_t maxSessionCount = 30);
+
+		SessionPool(const SessionPool&) = delete;
+		SessionPool(SessionPool&&) = delete;
+		SessionPool& operator=(const SessionPool&) = delete;
+		SessionPool& operator=(SessionPool&&) = delete;
+
+	private:
+		friend class ScopedSession;
+		Session& acquireSession();
+		void releaseSession(Session& session);
+
+		std::mutex	_mutex;
+		Db&		_db;
+		std::size_t	_maxSessionCount;
+		std::vector<std::unique_ptr<Session>>	_freeSessions;
+		std::vector<std::unique_ptr<Session>>	_acquiredSessions;
+};
+
+} // namespace Database
+
+

src/liblms/include/database/Track.hpp

@@ -0,0 +1,189 @@
+/*
+ * 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 <vector>
+#include <string>
+
+#include <Wt/Dbo/Dbo.h>
+#include <Wt/WDateTime.h>
+
+#include "utils/UUID.hpp"
+
+#include "TrackArtistLink.hpp"
+#include "Types.hpp"
+
+namespace Database {
+
+class Artist;
+class Cluster;
+class ClusterType;
+class Release;
+class TrackFeatures;
+class TrackListEntry;
+class TrackStats;
+class User;
+
+class Track : public Wt::Dbo::Dbo<Track>
+{
+	public:
+
+		using pointer = Wt::Dbo::ptr<Track>;
+
+		Track() {}
+		Track(const std::filesystem::path& p);
+
+		// Find utility functions
+		static pointer getByPath(Session& session, const std::filesystem::path& p);
+		static pointer getById(Session& session, IdType id);
+		static pointer getByMBID(Session& session, const UUID& MBID);
+		static std::vector<pointer>	getSimilarTracks(Session& session,
+							const std::set<IdType>& trackIds,
+							std::optional<std::size_t> offset = {},
+							std::optional<std::size_t> size = {});
+		static std::vector<pointer>	getByClusters(Session& session,
+							const std::set<IdType>& clusters);           // tracks that belong to these clusters
+		static std::vector<pointer>	getByFilter(Session& session,
+							const std::set<IdType>& clusters,            // if non empty, tracks that belong to these clusters
+							const std::vector<std::string>& keywords,    // if non empty, name must match all of these keywords
+							std::optional<std::size_t> offset,
+							std::optional<std::size_t> size,
+							bool& moreExpected);
+
+		static std::vector<pointer>	getAll(Session& session, std::optional<std::size_t> limit = {});
+		static std::vector<pointer>	getAllRandom(Session& session, std::optional<std::size_t> limit = {});
+		static std::vector<IdType>	getAllIds(Session& session);
+		static std::vector<std::filesystem::path> getAllPaths(Session& session);
+		static std::vector<pointer>	getMBIDDuplicates(Session& session);
+		static std::vector<pointer>	getLastAdded(Session& session, const Wt::WDateTime& after, std::optional<std::size_t> size = 1);
+		static std::vector<pointer>	getAllWithMBIDAndMissingFeatures(Session& session);
+		static std::vector<IdType>	getAllIdsWithFeatures(Session& session, std::optional<std::size_t> limit = {});
+
+		// 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 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 setYear(int year)						{ _year = year; }
+		void setOriginalYear(int year)					{ _originalYear = year; }
+		void setHasCover(bool hasCover)					{ _hasCover = hasCover; }
+		void setMBID(const std::optional<UUID>& MBID)			{ _MBID = 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 clearArtistLinks();
+		void addArtistLink(const Wt::Dbo::ptr<TrackArtistLink>& artistLink);
+		void setRelease(Wt::Dbo::ptr<Release> release)			{ _release = release; }
+		void setClusters(const std::vector<Wt::Dbo::ptr<Cluster>>& clusters );
+		void setFeatures(const Wt::Dbo::ptr<TrackFeatures>& features);
+
+		std::size_t 				getScanVersion() const		{ return _scanVersion; }
+		std::optional<std::size_t>		getTrackNumber() const;
+		std::optional<std::size_t>		getDiscNumber() const;
+		std::string 				getName() const			{ return _name; }
+		std::filesystem::path			getPath() const			{ return _filePath; }
+		std::chrono::milliseconds		getDuration() const		{ return _duration; }
+		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>			getMBID() const			{ return UUID::fromString(_MBID); }
+		std::optional<std::string>		getCopyright() const;
+		std::optional<std::string>		getCopyrightURL() const;
+		std::vector<Wt::Dbo::ptr<Artist>>	getArtists(TrackArtistLink::Type type = TrackArtistLink::Type::Artist) const;
+		std::vector<IdType>			getArtistIds(TrackArtistLink::Type type = TrackArtistLink::Type::Artist) const;
+		std::vector<Wt::Dbo::ptr<TrackArtistLink>>	getArtistLinks() const;
+		Wt::Dbo::ptr<Release>			getRelease() const		{ return _release; }
+		std::vector<Wt::Dbo::ptr<Cluster>>	getClusters() const;
+		std::vector<IdType>			getClusterIds() const;
+		bool					hasTrackFeatures() const;
+		Wt::Dbo::ptr<TrackFeatures>		getTrackFeatures() const;
+
+		std::vector<std::vector<Wt::Dbo::ptr<Cluster>>> getClusterGroups(std::vector<Wt::Dbo::ptr<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, _name,		"name");
+				Wt::Dbo::field(a, _duration,		"duration");
+				Wt::Dbo::field(a, _year,		"year");
+				Wt::Dbo::field(a, _originalYear,	"original_year");
+				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, _MBID,		"mbid");
+				Wt::Dbo::field(a, _copyright,		"copyright");
+				Wt::Dbo::field(a, _copyrightURL,	"copyright_url");
+				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 = 0;
+		int					_trackNumber = 0;
+		int					_discNumber = 0;
+		std::string				_name;
+		std::string				_artistName;
+		std::string				_releaseName;
+		std::chrono::duration<int, std::milli>	_duration;
+		int					_year = 0;
+		int					_originalYear = 0;
+		std::string				_filePath;
+		Wt::WDateTime				_fileLastWrite;
+		Wt::WDateTime				_fileAdded;
+		bool					_hasCover = false;
+		std::string				_MBID; // Musicbrainz Identifier
+		std::string				_copyright;
+		std::string				_copyrightURL;
+
+		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/liblms/include/database/TrackArtistLink.hpp

@@ -0,0 +1,82 @@
+/*
+ * 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 <Wt/Dbo/Dbo.h>
+
+#include "Types.hpp"
+
+namespace Database {
+
+class Artist;
+class Session;
+class Track;
+
+class TrackArtistLink
+{
+	public:
+		enum class Type
+		{
+			Artist,	// regular artist
+			Arranger,
+			Composer,
+			Conductor,
+			Lyricist,
+			Mixer,
+			Performer,
+			Producer,
+			ReleaseArtist,
+			Remixer,
+			Writer,
+		};
+
+		using pointer = Wt::Dbo::ptr<TrackArtistLink>;
+
+		TrackArtistLink() = default;
+		TrackArtistLink(Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr<Artist> artist, Type type);
+
+		static pointer create(Session& session, Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr<Artist> artist,Type type);
+
+		Wt::Dbo::ptr<Track>	getTrack() const { return _track; }
+		Wt::Dbo::ptr<Artist>	getArtist() const { return _artist; }
+		Type			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:
+
+		Type		_type;
+		std::string	_name;
+
+		Wt::Dbo::ptr<Track> _track;
+		Wt::Dbo::ptr<Artist> _artist;
+};
+
+}
+
+

src/liblms/include/database/TrackBookmark.hpp

@@ -0,0 +1,82 @@
+/*
+ * 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 "Types.hpp"
+
+namespace Database {
+
+class Session;
+class Track;
+class User;
+
+class TrackBookmark : public Wt::Dbo::Dbo<TrackBookmark>
+{
+	public:
+		using pointer = Wt::Dbo::ptr<TrackBookmark>;
+
+		TrackBookmark () = default;
+		TrackBookmark(Wt::Dbo::ptr<User> user, Wt::Dbo::ptr<Track> track);
+
+		// utility
+		static pointer create(Session& session, Wt::Dbo::ptr<User> user, Wt::Dbo::ptr<Track> track);
+
+		// Find utility functions
+		static std::vector<pointer>	getAll(Session& session);
+		static std::vector<pointer>	getByUser(Session& session, Wt::Dbo::ptr<User> user);
+		static pointer			getByUser(Session& session, Wt::Dbo::ptr<User> user, Wt::Dbo::ptr<Track> track);
+		static pointer			getById(Session& session, IdType 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; }
+		Wt::Dbo::ptr<Track>		getTrack() const	{ return _track; }
+		Wt::Dbo::ptr<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/liblms/include/database/TrackFeatures.hpp

@@ -0,0 +1,71 @@
+/*
+ * 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 "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 Wt::Dbo::Dbo<TrackFeatures>
+{
+	public:
+
+		using pointer = Wt::Dbo::ptr<TrackFeatures>;
+
+		TrackFeatures() = default;
+		TrackFeatures(Wt::Dbo::ptr<Track> track, const std::string& jsonEncodedFeatures);
+
+		// Create utility
+		static pointer create(Session& session, Wt::Dbo::ptr<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/liblms/include/database/TrackList.hpp

@@ -0,0 +1,150 @@
+/*
+ * 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 <Wt/Dbo/Dbo.h>
+
+#include "Types.hpp"
+
+namespace Database {
+
+class Artist;
+class Cluster;
+class Release;
+class Session;
+class Track;
+class TrackListEntry;
+class User;
+
+class TrackList : public Wt::Dbo::Dbo<TrackList>
+{
+	public:
+		using pointer = Wt::Dbo::ptr<TrackList>;
+
+		enum class Type
+		{
+			Playlist,  // user controlled playlists
+			Internal,  // current playqueue, history
+		};
+
+		TrackList() = default;
+		TrackList(const std::string& name, Type type, bool isPublic, Wt::Dbo::ptr<User> user);
+
+		// Stats utility
+		std::vector<Wt::Dbo::ptr<Artist>> getTopArtists(std::size_t limit = 1) const;
+		std::vector<Wt::Dbo::ptr<Release>> getTopReleases(std::size_t limit = 1) const;
+		std::vector<Wt::Dbo::ptr<Track>> getTopTracks(std::size_t limit = 1) const;
+
+		// Search utility
+		static pointer	get(Session& session, const std::string& name, Type type, Wt::Dbo::ptr<User> user);
+		static pointer	getById(Session& session, IdType tracklistId);
+		static std::vector<pointer> getAll(Session& session);
+		static std::vector<pointer> getAll(Session& session, Wt::Dbo::ptr<User> user);
+		static std::vector<pointer> getAll(Session& session, Wt::Dbo::ptr<User> user, Type type);
+
+		// Create utility
+		static pointer	create(Session& session, const std::string& name, Type type, bool isPublic, Wt::Dbo::ptr<User> user);
+
+		// Accessors
+		std::string	getName() const { return _name; }
+		bool		isPublic() const { return _isPublic; }
+		Type		getType() const { return _type; }
+		Wt::Dbo::ptr<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
+		std::size_t getCount() const;
+		Wt::Dbo::ptr<TrackListEntry> getEntry(std::size_t pos) const;
+		std::vector<Wt::Dbo::ptr<TrackListEntry>> getEntries(std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {}) const;
+		std::vector<Wt::Dbo::ptr<TrackListEntry>> getEntriesReverse(std::optional<std::size_t>  offset = {}, std::optional<std::size_t> size = {}) const;
+
+		std::vector<IdType> getTrackIds() const;
+
+		std::chrono::milliseconds getDuration() const;
+
+		// Get clusters, order by occurence
+		std::vector<Wt::Dbo::ptr<Cluster>> getClusters() const;
+
+		bool hasTrack(IdType trackId) const;
+
+		// Ordered from most clusters in common
+		std::vector<Wt::Dbo::ptr<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 Wt::Dbo::Dbo<TrackListEntry>
+{
+	public:
+
+		using pointer = Wt::Dbo::ptr<TrackListEntry>;
+
+		TrackListEntry() = default;
+		TrackListEntry(Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr<TrackList> tracklist);
+
+		static pointer getById(Session& session, IdType id);
+
+		// Create utility
+		static pointer create(Session& session, Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr<TrackList> tracklist);
+
+		// Accessors
+		Wt::Dbo::ptr<Track>	getTrack() const { return _track; }
+
+		template<class Action>
+		void persist(Action& a)
+		{
+			Wt::Dbo::belongsTo(a,	_track, "track", Wt::Dbo::OnDeleteCascade);
+			Wt::Dbo::belongsTo(a,	_tracklist, "tracklist", Wt::Dbo::OnDeleteCascade);
+		}
+
+	private:
+
+		Wt::Dbo::ptr<Track>	_track;
+		Wt::Dbo::ptr<TrackList>	_tracklist;
+};
+
+} // namespace Database
+

src/liblms/include/database/Types.hpp

@@ -0,0 +1,32 @@
+/*
+ * 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 <Wt/Dbo/ptr.h>
+
+namespace Database {
+	using IdType = Wt::Dbo::dbo_default_traits::IdType;
+
+	static inline bool IdIsValid(IdType id)
+	{
+		return id != Wt::Dbo::dbo_default_traits::invalidId();
+	}
+}
+

src/liblms/include/database/User.hpp

@@ -0,0 +1,230 @@
+/*
+ * 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 <vector>
+
+#include <Wt/Dbo/Dbo.h>
+#include <Wt/WDateTime.h>
+
+#include "Types.hpp"
+
+namespace Database {
+
+
+class Artist;
+class Release;
+class Session;
+class TrackList;
+class Track;
+
+// User selectable audio 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::size_t;
+
+class User;
+class AuthToken
+{
+	public:
+
+		using pointer = Wt::Dbo::ptr<AuthToken>;
+
+		AuthToken() = default;
+		AuthToken(const std::string& value, const Wt::WDateTime& expiry, Wt::Dbo::ptr<User> user);
+
+		// Utility
+		static pointer create(Session& session, const std::string& value, const Wt::WDateTime&expiry, Wt::Dbo::ptr<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, IdType tokenId);
+
+		// Accessors
+		const Wt::WDateTime&	getExpiry() const { return _expiry; }
+		Wt::Dbo::ptr<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 Wt::Dbo::Dbo<User>
+{
+	public:
+		using pointer = Wt::Dbo::ptr<User>;
+
+		static const std::size_t MinNameLength = 3;
+		static const std::size_t MaxNameLength = 15;
+
+		enum class Type
+		{
+			REGULAR,
+			ADMIN,
+			DEMO
+		};
+
+		struct PasswordHash
+		{
+			std::string salt;
+			std::string hash;
+		};
+
+		// list of audio parameters
+		static const std::set<Bitrate> audioTranscodeAllowedBitrates;
+
+		User();
+		User(const std::string& loginName, const PasswordHash& passwordHash);
+
+		// utility
+		static pointer create(Session& session, const std::string& loginName, const PasswordHash& passwordHash);
+
+		static pointer			getById(Session& session, IdType id);
+		static pointer			getByLoginName(Session& session, const std::string& loginName);
+		static std::vector<pointer>	getAll(Session& session);
+		static pointer			getDemo(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(Type type)					{ _type = type; }
+		void setAudioTranscodeEnable(bool value) 		{ _audioTranscodeEnable = value; }
+		void setAudioTranscodeFormat(AudioFormat format)	{ _audioTranscodeFormat = format; }
+		void setAudioTranscodeBitrate(Bitrate bitrate);
+		void setMaxAudioTranscodeBitrate(Bitrate bitrate);
+		void setCurPlayingTrackPos(std::size_t pos)		{ _curPlayingTrackPos = pos; }
+		void setRadio(bool val)					{ _radio = val; }
+		void setRepeatAll(bool val)				{ _repeatAll = val; }
+		void clearAuthTokens();
+
+		// read
+		bool			isAdmin() const { return _type == Type::ADMIN; }
+		bool			isDemo() const { return _type == Type::DEMO; }
+		bool			getAudioTranscodeEnable() const { return _audioTranscodeEnable; }
+		Bitrate			getAudioTranscodeBitrate() const;
+		AudioFormat		getAudioTranscodeFormat() const { return _audioTranscodeFormat; }
+		Bitrate			getMaxAudioTranscodeBitrate() const;
+		std::size_t		getCurPlayingTrackPos() const { return _curPlayingTrackPos; }
+		bool			isRepeatAllSet() const { return _repeatAll; }
+		bool			isRadioSet() const { return _radio; }
+
+		Wt::Dbo::ptr<TrackList>	getPlayedTrackList(Session& session) const;
+		Wt::Dbo::ptr<TrackList>	getQueuedTrackList(Session& session) const;
+
+		void			starArtist(Wt::Dbo::ptr<Artist> artist);
+		void			unstarArtist(Wt::Dbo::ptr<Artist> artist);
+		bool			hasStarredArtist(Wt::Dbo::ptr<Artist> artist) const;
+		std::vector<Wt::Dbo::ptr<Artist>> getStarredArtists() const;
+
+		void			starRelease(Wt::Dbo::ptr<Release> release);
+		void			unstarRelease(Wt::Dbo::ptr<Release> release);
+		bool			hasStarredRelease(Wt::Dbo::ptr<Release> release) const;
+		std::vector<Wt::Dbo::ptr<Release>> getStarredReleases(std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {}) const;
+
+		// Stars
+		void			starTrack(Wt::Dbo::ptr<Track> track);
+		void			unstarTrack(Wt::Dbo::ptr<Track> track);
+		bool			hasStarredTrack(Wt::Dbo::ptr<Track> track) const;
+		std::vector<Wt::Dbo::ptr<Track>> getStarredTracks() 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, _maxAudioTranscodeBitrate, "max_audio_bitrate");
+			Wt::Dbo::field(a, _audioTranscodeEnable, "audio_transcode_enable");
+			Wt::Dbo::field(a, _audioTranscodeBitrate, "audio_transcode_bitrate");
+			Wt::Dbo::field(a, _audioTranscodeFormat, "audio_transcode_format");
+			// User's dynamic data
+			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:
+
+		static const bool		defaultAudioTranscodeEnable {true};
+		static const AudioFormat	defaultAudioTranscodeFormat {AudioFormat::OGG_OPUS};
+		static const Bitrate		defaultAudioTranscodeBitrate {128000};
+
+		std::string	_loginName;
+		std::string	_passwordSalt;
+		std::string	_passwordHash;
+		Wt::WDateTime	_lastLogin;
+
+		// Admin defined settings
+		int	 	_maxAudioTranscodeBitrate;
+		Type		_type {Type::REGULAR};
+
+		// User defined settings
+		bool		_audioTranscodeEnable {defaultAudioTranscodeEnable};
+		AudioFormat	_audioTranscodeFormat {defaultAudioTranscodeFormat};
+		int		_audioTranscodeBitrate {defaultAudioTranscodeBitrate};
+
+		// 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/liblms/include/metadata/AvFormat.hpp

@@ -0,0 +1,35 @@
+/*
+ * 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 "MetaData.hpp"
+
+namespace MetaData
+{
+
+// Parse that makes use of AvFormat
+class AvFormat : public Parser
+{
+	public:
+		std::optional<Track> parse(const std::filesystem::path& p, bool debug = false) override;
+};
+
+} // namespace MetaData
+

src/liblms/include/metadata/MetaData.hpp

@@ -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/>.
+ */
+
+#pragma once
+
+#include <chrono>
+#include <filesystem>
+#include <map>
+#include <optional>
+#include <set>
+#include <vector>
+
+//#include "utils/Utils.hpp"
+#include "utils/UUID.hpp"
+
+namespace MetaData
+{
+	using Clusters = std::map<std::string /* type */, std::set<std::string> /* names */>;
+
+	struct Artist
+	{
+		std::string name;
+		std::optional<UUID> musicBrainzArtistID;
+	};
+
+	struct Album
+	{
+		std::string name;
+		std::optional<UUID> musicBrainzAlbumID;
+	};
+
+	struct AudioStream
+	{
+		unsigned bitRate;
+	};
+
+	struct Track
+	{
+		std::vector<Artist>		artists;
+		std::vector<Artist>		albumArtists;
+		std::string			title;
+		std::optional<UUID>		musicBrainzTrackID;
+		std::optional<UUID>		musicBrainzRecordID;
+		std::optional<Album>		album;
+		Clusters			clusters;
+		std::chrono::milliseconds 	duration {};
+		std::optional<std::size_t>	trackNumber;
+		std::optional<std::size_t>	totalTrack;
+		std::optional<std::size_t>	discNumber;
+		std::optional<std::size_t>	totalDisc;
+		std::optional<int>		year;
+		std::optional<int>		originalYear;
+		bool				hasCover {false};
+		std::vector<AudioStream>	audioStreams;
+		std::optional<UUID>		acoustID;
+		std::string			copyright;
+		std::string			copyrightURL;
+	};
+
+	class Parser
+	{
+		public:
+			virtual std::optional<Track> parse(const std::filesystem::path& p, bool debug = false) = 0;
+
+			void setClusterTypeNames(const std::set<std::string>& clusterTypeNames) { _clusterTypeNames = clusterTypeNames; }
+
+		protected:
+			std::set<std::string> _clusterTypeNames;
+	};
+
+} // namespace MetaData
+

src/liblms/include/metadata/TagLibParser.hpp

@@ -0,0 +1,35 @@
+/*
+ * 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 "MetaData.hpp"
+
+namespace MetaData
+{
+
+// Parse that makes use of AvFormat
+class TagLibParser : public Parser
+{
+	public:
+		std::optional<Track> parse(const std::filesystem::path& p, bool debug = false) override;
+};
+
+} // namespace MetaData
+

src/liblms/include/recommendation/ClustersRecommendationProviderCreator.hpp

@@ -0,0 +1,35 @@
+/*
+ * 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 Session;
+}
+
+namespace Recommendation
+{
+	class Provider;
+
+	std::unique_ptr<Provider> createClustersRecommendationProvider();
+}
+

src/liblms/include/recommendation/FeaturesRecommendationProviderCreator.hpp

@@ -0,0 +1,40 @@
+/*
+ * 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 Session;
+}
+
+namespace Scanner
+{
+	class MediaScanner;
+}
+
+namespace Recommendation
+{
+	class Provider;
+
+	std::unique_ptr<Provider> createFeaturesRecommendationProvider(Scanner::MediaScanner& scanner);
+}
+

src/liblms/include/recommendation/IEngine.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 <vector>
+#include <unordered_set>
+
+#include "database/Types.hpp"
+#include "Provider.hpp"
+
+namespace Database
+{
+	class Session;
+}
+
+namespace Recommendation
+{
+	class Provider;
+	class IEngine
+	{
+		public:
+			virtual ~IEngine() = default;
+
+			virtual void clearProviders() = 0;
+			virtual void addProvider(std::unique_ptr<Provider> provider, unsigned priority) = 0;
+
+			// Closest results first
+			virtual std::vector<Database::IdType> getSimilarTracksFromTrackList(Database::Session& session, Database::IdType tracklistId, std::size_t maxCount) = 0;
+			virtual std::vector<Database::IdType> getSimilarTracks(Database::Session& session, const std::unordered_set<Database::IdType>& tracksId, std::size_t maxCount) = 0;
+			virtual std::vector<Database::IdType> getSimilarReleases(Database::Session& session, Database::IdType releaseId, std::size_t maxCount) = 0;
+			virtual std::vector<Database::IdType> getSimilarArtists(Database::Session& session, Database::IdType artistId, std::size_t maxCount) = 0;
+	};
+
+	std::unique_ptr<IEngine> createEngine();
+
+} // ns Recommendation
+

src/liblms/include/recommendation/Provider.hpp

@@ -0,0 +1,50 @@
+/*
+ * 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 <unordered_set>
+#include <vector>
+
+#include "database/Types.hpp"
+
+namespace Database
+{
+	class Session;
+}
+
+namespace Recommendation
+{
+
+	class Provider
+	{
+		public:
+			virtual ~Provider() = default;
+
+			virtual bool isTrackClassified(Database::IdType trackId) const = 0;
+			virtual bool isReleaseClassified(Database::IdType releaseId) const = 0;
+			virtual bool isArtistClassified(Database::IdType artistId) const = 0;
+
+			virtual std::vector<Database::IdType> getSimilarTracksFromTrackList(Database::Session& session, Database::IdType tracklistId, std::size_t maxCount) = 0;
+			virtual std::vector<Database::IdType> getSimilarTracks(Database::Session& session, const std::unordered_set<Database::IdType>& tracksId, std::size_t maxCount) const = 0;
+			virtual std::vector<Database::IdType> getSimilarReleases(Database::IdType releaseId, std::size_t maxCount) const = 0;
+			virtual std::vector<Database::IdType> getSimilarArtists(Database::IdType artistId, std::size_t maxCount) const = 0;
+	};
+
+} // ns Recommendation

src/liblms/include/scanner/MediaScanner.hpp

@@ -0,0 +1,134 @@
+/*
+ * 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 <mutex>
+#include <optional>
+
+#include <Wt/WDateTime.h>
+#include <Wt/WIOService.h>
+#include <Wt/WSignal.h>
+
+#include <boost/asio/system_timer.hpp>
+
+#include "database/ScanSettings.hpp"
+#include "database/Session.hpp"
+#include "metadata/TagLibParser.hpp"
+
+#include "MediaScannerAddon.hpp"
+#include "MediaScannerStats.hpp"
+
+namespace Scanner {
+
+class MediaScanner
+{
+	public:
+		MediaScanner(Database::Db& db);
+
+		void setAddon(MediaScannerAddon& addon);
+
+		void start();
+		void stop();
+		void restart();
+
+		// Async requests
+		void requestImmediateScan();
+		void requestReschedule();
+
+
+		enum class State
+		{
+			NotScheduled,
+			Scheduled,
+			InProgress,
+		};
+
+		struct Status
+		{
+			State					currentState {State::NotScheduled};
+			Wt::WDateTime				nextScheduledScan;
+			std::optional<ScanStats>		lastCompleteScanStats;
+			std::optional<ScanProgressStats>	inProgressScanStats;
+		};
+
+		Status getStatus();
+
+		// Called just after scan complete
+		Wt::Signal<>& scanComplete() { return _sigScanComplete; }
+
+		// Called during scan in progress
+		Wt::Signal<ScanProgressStats>& scanInProgress() { return _sigScanInProgress; }
+
+		// Called after a schedule
+		Wt::Signal<Wt::WDateTime>& scheduled() { return _sigScheduled; }
+
+	private:
+
+		// Job handling
+		void scheduleNextScan();
+		void scheduleScan(const Wt::WDateTime& dateTime = {});
+
+		// Update database (scheduled callback)
+		void scan(boost::system::error_code ec);
+
+		void scanMediaDirectory( const std::filesystem::path& mediaDirectory, bool forceScan, 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);
+		Database::IdType doScanAudioFile(const std::filesystem::path& file, ScanStats& stats);
+		void notifyInProgressIfNeeded(const ScanStats& stats);
+		void notifyInProgress(const ScanStats& stats);
+
+		bool					_running {false};
+		Wt::WIOService				_ioService;
+		boost::asio::system_timer		_scheduleTimer {_ioService};
+		Wt::Signal<>				_sigScanComplete;
+		Wt::Signal<ScanProgressStats>		_sigScanInProgress;
+		std::chrono::system_clock::time_point	_lastScanInProgressEmit {};
+		Wt::Signal<Wt::WDateTime>		_sigScheduled;
+		Database::Session			_dbSession;
+		MetaData::TagLibParser 			_metadataParser;
+		std::vector<MediaScannerAddon*> 	_addons;
+
+		std::mutex				_statusMutex;
+		State					_curState {State::NotScheduled};
+		std::optional<ScanStats> 		_lastCompleteScanStats;
+		std::optional<ScanProgressStats> 	_inProgressScanStats;
+		Wt::WDateTime				_nextScheduledScan;
+
+		// Current scan settings
+		std::size_t _scanVersion {};
+		Wt::WTime _startTime;
+		Database::ScanSettings::UpdatePeriod 	_updatePeriod {Database::ScanSettings::UpdatePeriod::Never};
+		std::set<std::filesystem::path>		_fileExtensions;
+		std::filesystem::path			_mediaDirectory;
+
+
+}; // class MediaScanner
+
+} // Scanner
+

src/liblms/include/scanner/MediaScannerAddon.hpp

@@ -0,0 +1,41 @@
+/*
+ * 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 "database/Types.hpp"
+
+namespace Scanner {
+
+class MediaScannerAddon
+{
+	public:
+
+		virtual void refreshSettings() = 0;
+		virtual void requestStop() = 0;
+		virtual void preScanComplete() = 0;
+
+		virtual void trackAdded(Database::IdType trackId) = 0;
+		virtual void trackToRemove(Database::IdType trackId) = 0;
+		virtual void trackUpdated(Database::IdType trackId) = 0;
+
+};
+
+} // ns Scanner
+

src/liblms/include/scanner/MediaScannerStats.hpp

@@ -0,0 +1,94 @@
+/*
+ * 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>
+
+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
+	{
+		std::filesystem::path   file;
+		DuplicateReason		reason;
+
+	};
+
+	// reduced scan stats
+	struct ScanProgressStats
+	{
+		Wt::WDateTime   startTime;
+
+		std::size_t     filesToScan {};
+		std::size_t	processedFiles {};
+
+		unsigned	progress() const;
+	};
+
+	struct ScanStats
+	{
+		Wt::WDateTime	startTime;
+		Wt::WDateTime	stopTime;
+
+		std::size_t	filesToScan {};		// Total number of files to be 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::vector<ScanError>		errors;
+		std::vector<ScanDuplicate>	duplicates;
+
+		std::size_t	nbFiles() const;
+		std::size_t	nbChanges() const;
+
+		ScanProgressStats toProgressStats() const;
+	};
+
+}
+

src/liblms/include/utils/Exception.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 <stdexcept>
+#include <string>
+
+class LmsException : public std::runtime_error
+{
+	public:
+		LmsException(const std::string& error = "") : std::runtime_error {error} {}
+};
+

src/liblms/include/utils/IConfig.hpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 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 <filesystem>
+#include <memory>
+#include <unordered_set>
+
+// Used to get config values from configuration files
+class IConfig
+{
+	public:
+
+		// Default values are returned in case of setting not found
+		virtual std::string	getString(const std::string& setting, const std::string& def = "", const std::unordered_set<std::string>& allowedValues = {}) = 0;
+		virtual std::filesystem::path getPath(const std::string& setting, const std::filesystem::path& def = std::filesystem::path()) = 0;
+		virtual unsigned long	getULong(const std::string& setting, unsigned long def = 0) = 0;
+		virtual long		getLong(const std::string& setting, long def = 0) = 0;
+		virtual bool		getBool(const std::string& setting, bool def = false) = 0;
+};
+
+
+std::unique_ptr<IConfig> createConfig(const std::filesystem::path& p);
+

src/liblms/include/utils/Logger.hpp

@@ -0,0 +1,84 @@
+/*
+ * 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 <string>
+#include <sstream>
+
+#include "Service.hpp"
+
+enum class Severity
+{
+	FATAL,
+	ERROR,
+	WARNING,
+	INFO,
+	DEBUG,
+};
+
+enum class Module
+{
+	API_SUBSONIC,
+	AUTH,
+	AV,
+	COVER,
+	DB,
+	DBUPDATER,
+	FEATURE,
+	MAIN,
+	METADATA,
+	REMOTE,
+	SERVICE,
+	SIMILARITY,
+	TRANSCODE,
+	UI,
+};
+
+const char* getModuleName(Module mod);
+const char* getSeverityName(Severity sev);
+
+class Logger;
+class Log
+{
+	public:
+		Log(Logger* logger, Module module, Severity severity);
+		~Log();
+
+		Module getModule() const { return _module; }
+		Severity getSeverity() const { return _severity; }
+		std::string getMessage() const;
+
+		std::ostringstream& getOstream() { return _oss; }
+
+	private:
+		Module _module;
+		Severity _severity;
+		std::ostringstream _oss;
+		Logger* _logger {};
+};
+
+class Logger
+{
+	public:
+		virtual void processLog(const Log& log) = 0;
+};
+
+#define LMS_LOG(module, severity)	Log(ServiceProvider<Logger>::get(), Module::module, Severity::severity).getOstream()
+

src/liblms/include/utils/NetAddress.hpp

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2019 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <boost/asio/ip/address.hpp>
+
+namespace std
+{
+	template<> struct hash<boost::asio::ip::address>
+	{
+		std::size_t operator()(const boost::asio::ip::address& ipAddr) const;
+	};
+
+}
+
+

src/liblms/include/utils/Path.hpp

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 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 <filesystem>
+#include <string>
+#include <vector>
+
+#include <Wt/WDateTime.h>
+
+void computeCrc(const std::filesystem::path& p, std::vector<unsigned char>& checksum);
+
+// Make sure the given path is a directory
+// Create it if needed
+bool ensureDirectory(const std::filesystem::path& dir);
+
+// Get the last write time since Epoch
+Wt::WDateTime getLastWriteTime(const std::filesystem::path& dir);
+

src/liblms/include/utils/Random.hpp

@@ -0,0 +1,64 @@
+/*
+ * 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 <algorithm>
+#include <random>
+
+namespace Random {
+
+using RandGenerator = std::mt19937;
+RandGenerator& getRandGenerator();
+
+template <typename T>
+T
+getRandom(T min, T max)
+{
+	std::uniform_int_distribution<> dist {min, max};
+	return dist (getRandGenerator());
+}
+
+template <typename T>
+T
+getRealRandom(T min, T max)
+{
+	std::uniform_real_distribution<> dist {min, max};
+	return dist (getRandGenerator());
+}
+
+template <typename Container>
+void
+shuffleContainer(Container& container)
+{
+	std::shuffle(std::begin(container), std::end(container), getRandGenerator());
+}
+
+template <typename Container>
+typename Container::const_iterator
+pickRandom(const Container& container)
+{
+	if (container.empty())
+		return std::end(container);
+
+	return std::next(std::begin(container), getRandom(0, static_cast<int>(container.size() - 1)));
+}
+
+}
+

src/liblms/include/utils/Service.hpp

@@ -0,0 +1,64 @@
+/*
+ * 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 <memory>
+#include <type_traits>
+
+template <typename Class>
+class ServiceProvider
+{
+	public:
+		template <class DerivedClass, class ...Args>
+		static
+		Class&
+		create(Args&&... args)
+		{
+			static_assert(std::is_base_of<Class, DerivedClass>::value);
+
+			assign(std::make_unique<DerivedClass>(std::forward<Args>(args)...));
+			return *get();
+		}
+
+		template <class ...Args>
+		static
+		Class&
+		create(Args&&... args)
+		{
+			assign(std::make_unique<Class>(std::forward<Args>(args)...));
+			return *get();
+		}
+
+		static
+		Class&
+		assign(std::unique_ptr<Class> service)
+		{
+			_service = std::move(service);
+			return *get();
+		}
+
+		static void clear() { _service.reset(); }
+
+		static Class* get() { return _service.get(); }
+
+	private:
+		static inline std::unique_ptr<Class> _service;
+};
+

src/liblms/include/utils/StreamLogger.hpp

@@ -0,0 +1,34 @@
+/*
+ * 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 "Logger.hpp"
+
+class StreamLogger final : public Logger
+{
+	public:
+		StreamLogger(std::ostream& oss);
+
+		void processLog(const Log& log);
+
+	private:
+		std::ostream& _os;
+};
+

src/liblms/include/utils/String.hpp

@@ -0,0 +1,77 @@
+/*
+ * 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 <optional>
+#include <string>
+#include <sstream>
+#include <vector>
+
+namespace StringUtils {
+
+
+std::vector<std::string>
+splitString(const std::string& string, const std::string& separators);
+
+std::string
+joinStrings(const std::vector<std::string>& strings, const std::string& delimiter);
+
+std::string
+stringTrim(const std::string& str, const std::string& whitespaces = " \t");
+
+std::string
+stringTrimEnd(const std::string& str, const std::string& whitespaces = " \t");
+
+std::string
+stringToLower(const std::string& str);
+
+std::string
+stringToUpper(const std::string& str);
+
+std::string
+bufferToString(const std::vector<unsigned char>& data);
+
+template<typename T>
+std::optional<T> readAs(const std::string& str)
+{
+	T res;
+
+	std::istringstream iss ( str );
+	iss >> res;
+	if (iss.fail())
+		return std::nullopt;
+
+	return res;
+}
+
+std::string
+replaceInString(const std::string& str, const std::string& from, const std::string& to);
+
+std::string
+jsEscape(const std::string& str);
+
+bool
+stringEndsWith(const std::string& str, const std::string& ending);
+
+std::optional<std::string>
+stringFromHex(const std::string& str);
+
+} // StringUtils
+

src/liblms/include/utils/UUID.hpp

@@ -0,0 +1,47 @@
+/*
+ * 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 <optional>
+#include <string>
+#include <string_view>
+
+#include "utils/String.hpp"
+
+class UUID
+{
+	public:
+
+		static std::optional<UUID> fromString(std::string_view str);
+
+		std::string_view getAsString() const { return _value; }
+
+	private:
+		UUID(std::string_view value) : _value {value} {}
+		std::string _value;
+};
+
+namespace StringUtils
+{
+	template <>
+	std::optional<UUID>
+	readAs(const std::string& str);
+}
+

src/liblms/include/utils/Utils.hpp

@@ -0,0 +1,30 @@
+/*
+ * 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 <functional>
+
+template<class T, class Compare = std::less<>>
+constexpr T clamp(T v, T lo, T hi, Compare comp = {})
+{
+	assert(!comp(hi, lo));
+	return comp(v, lo) ? lo : comp(hi, v) ? hi : v;
+}
+

src/liblms/include/utils/WtLogger.hpp

@@ -0,0 +1,29 @@
+/*
+ * 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 "Logger.hpp"
+
+class WtLogger final : public Logger
+{
+	public:
+		void processLog(const Log& log) override;
+};
+