diff --git a/approot/messages.xml b/approot/messages.xml index cc8ba74c..1fcfeea3 100644 --- a/approot/messages.xml +++ b/approot/messages.xml @@ -190,12 +190,12 @@ Producers - Album artists - Album artist + Album artist + Album artists - Remixers - Remixer + Remixer + Remixers @@ -213,6 +213,7 @@ Compilation Demo DJ-mix +Field recording Interview Live Mixtape/Street diff --git a/approot/messages_fr.xml b/approot/messages_fr.xml index aca2df14..f396330e 100644 --- a/approot/messages_fr.xml +++ b/approot/messages_fr.xml @@ -204,21 +204,22 @@ Disque {1} Type Album -Broadcast +Diffusion EP Other Single -Audiobook -Audio drama +Livre audio +Drame audio Compilation -Demo +Démo DJ-mix +Enregistrement sur le terrain Interview Live Mixtape/Street Remix -Soundtrack -Spokenword +Bande son +Création parlée Supprimer la liste de lecture ? diff --git a/approot/messages_it.xml b/approot/messages_it.xml index 7baa5358..69d30b39 100644 --- a/approot/messages_it.xml +++ b/approot/messages_it.xml @@ -220,6 +220,7 @@ + diff --git a/approot/messages_zh.xml b/approot/messages_zh.xml index f3e20cea..60853a67 100644 --- a/approot/messages_zh.xml +++ b/approot/messages_zh.xml @@ -220,6 +220,7 @@ + 删除播放列表？ diff --git a/conf/lms.conf b/conf/lms.conf index 2013d7c0..34583eee 100644 --- a/conf/lms.conf +++ b/conf/lms.conf @@ -84,7 +84,10 @@ cover-max-cache-size = 30; cover-jpeg-quality = 75; # Preferred file names for covers (order is important) -cover-preferred-file-names = ("cover", "front" ); +cover-preferred-file-names = ("cover", "front"); + +# File names for artist images (order is important) +artist-image-file-names = ("artist"); # Playqueue max entry count playqueue-max-entry-count = 1000; diff --git a/src/libs/database/impl/Artist.cpp b/src/libs/database/impl/Artist.cpp index 47d062a1..9fca99a5 100644 --- a/src/libs/database/impl/Artist.cpp +++ b/src/libs/database/impl/Artist.cpp @@ -180,7 +180,7 @@ namespace Database return session.getDboSession().query("SELECT COUNT(*) FROM artist"); } - std::vector Artist::find(Session& session, const std::string& name) + std::vector Artist::find(Session& session, std::string_view name) { session.checkReadTransaction(); diff --git a/src/libs/database/impl/IdTypeTraits.hpp b/src/libs/database/impl/IdTypeTraits.hpp index bdfa0045..42dd2b2e 100644 --- a/src/libs/database/impl/IdTypeTraits.hpp +++ b/src/libs/database/impl/IdTypeTraits.hpp @@ -26,35 +26,34 @@ namespace Wt::Dbo { + template + struct sql_value_traits::value>::type> + { + static_assert(!std::is_same_v, "Cannot use IdType, use derived types"); + static const bool specialized = true; - template - struct sql_value_traits::value>::type> - { - static_assert(!std::is_same_v, "Cannot use IdType, use derived types"); - static const bool specialized = true; + static std::string type(SqlConnection* conn, int size) + { + return sql_value_traits::type(conn, size); + } - static std::string type(SqlConnection *conn, int size) - { - return sql_value_traits::type(conn, size); - } + static void bind(const T& v, SqlStatement* statement, int column, int size) + { + sql_value_traits::bind(v.getValue(), statement, column, size); + } - static void bind(const T& v, SqlStatement *statement, int column, int size) - { - sql_value_traits::bind(v.getValue(), statement, column, size); - } + static bool read(T& v, SqlStatement* statement, int column, int size) + { + typename T::ValueType value; + if (sql_value_traits::read(value, statement, column, size)) + { + v = value; + return true; + } - static bool read(T& v, SqlStatement *statement, int column, int size) - { - typename T::ValueType value; - if (sql_value_traits::read(value, statement, column, size)) - { - v = value; - return true; - } - - v = {}; - return false; - } - }; + v = {}; + return false; + } + }; } diff --git a/src/libs/database/impl/Listen.cpp b/src/libs/database/impl/Listen.cpp index 57005412..87391546 100644 --- a/src/libs/database/impl/Listen.cpp +++ b/src/libs/database/impl/Listen.cpp @@ -25,112 +25,113 @@ #include "SqlQuery.hpp" #include "Utils.hpp" -namespace -{ - using namespace Database; - - Wt::Dbo::Query createArtistsQuery(Wt::Dbo::Session& session, UserId userId, ScrobblingBackend backend, const std::vector& clusterIds, std::optional linkType) - { - auto query{ session.query("SELECT a.id from artist a") - .join("track t ON t.id = t_a_l.track_id") - .join("track_artist_link t_a_l ON t_a_l.artist_id = a.id") - .join("listen l ON l.track_id = t.id") - .where("l.user_id = ?").bind(userId) - .where("l.backend = ?").bind(backend) }; - - if (linkType) - query.where("t_a_l.type = ?").bind(*linkType); - - if (!clusterIds.empty()) - { - std::ostringstream oss; - oss << "a.id IN (SELECT DISTINCT a.id FROM artist a" - " INNER JOIN track t ON t.id = t_a_l.track_id" - " INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id" - " INNER JOIN cluster c ON c.id = t_c.cluster_id" - " INNER JOIN track_cluster t_c ON t_c.track_id = t.id"; - - WhereClause clusterClause; - for (auto id : clusterIds) - { - clusterClause.Or(WhereClause("c.id = ?")); - query.bind(id); - } - - oss << " " << clusterClause.get(); - oss << " GROUP BY t.id,a.id HAVING COUNT(DISTINCT c.id) = " << clusterIds.size() << ")"; - - query.where(oss.str()); - } - - return query; - } - - Wt::Dbo::Query createReleasesQuery(Wt::Dbo::Session& session, UserId userId, ScrobblingBackend backend, const std::vector& clusterIds) - { - auto query{ session.query("SELECT r.id from release r") - .join("track t ON t.release_id = r.id") - .join("listen l ON l.track_id = t.id") - .where("l.user_id = ?").bind(userId) - .where("l.backend = ?").bind(backend) }; - - if (!clusterIds.empty()) - { - std::ostringstream oss; - oss << "r.id IN (SELECT DISTINCT r.id FROM release r" - " INNER JOIN track t ON t.release_id = r.id" - " INNER JOIN cluster c ON c.id = t_c.cluster_id" - " INNER JOIN track_cluster t_c ON t_c.track_id = t.id"; - - WhereClause clusterClause; - for (ClusterId id : clusterIds) - { - clusterClause.Or(WhereClause("c.id = ?")); - query.bind(id); - } - - oss << " " << clusterClause.get(); - oss << " GROUP BY t.id HAVING COUNT(DISTINCT c.id) = " << clusterIds.size() << ")"; - - query.where(oss.str()); - } - - return query; - } - - Wt::Dbo::Query createTracksQuery(Wt::Dbo::Session& session, UserId userId, ScrobblingBackend backend, const std::vector& clusterIds) - { - auto query{ session.query("SELECT t.id from track t") - .join("listen l ON l.track_id = t.id") - .where("l.user_id = ?").bind(userId) - .where("l.backend = ?").bind(backend) }; - - if (!clusterIds.empty()) - { - std::ostringstream oss; - oss << "t.id IN (SELECT DISTINCT t.id FROM track t" - " INNER JOIN track_cluster t_c ON t_c.track_id = t.id" - " INNER JOIN cluster c ON c.id = t_c.cluster_id"; - - WhereClause clusterClause; - for (auto id : clusterIds) - { - clusterClause.Or(WhereClause("c.id = ?")).bind(id.toString()); - query.bind(id); - } - - oss << " " << clusterClause.get(); - oss << " GROUP BY t.id HAVING COUNT(*) = " << clusterIds.size() << ")"; - - query.where(oss.str()); - } - - return query; - } -} - namespace Database { + namespace + { + Wt::Dbo::Query createArtistsQuery(Wt::Dbo::Session& session, UserId userId, ScrobblingBackend backend, const std::vector& clusterIds, std::optional linkType) + { + auto query{ session.query("SELECT a.id from artist a") + .join("track t ON t.id = t_a_l.track_id") + .join("track_artist_link t_a_l ON t_a_l.artist_id = a.id") + .join("listen l ON l.track_id = t.id") + .where("l.user_id = ?").bind(userId) + .where("l.backend = ?").bind(backend) }; + + if (linkType) + query.where("t_a_l.type = ?").bind(*linkType); + + if (!clusterIds.empty()) + { + std::ostringstream oss; + oss << "a.id IN (SELECT DISTINCT a.id FROM artist a" + " INNER JOIN track t ON t.id = t_a_l.track_id" + " INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id" + " INNER JOIN cluster c ON c.id = t_c.cluster_id" + " INNER JOIN track_cluster t_c ON t_c.track_id = t.id"; + + WhereClause clusterClause; + for (auto id : clusterIds) + { + clusterClause.Or(WhereClause("c.id = ?")); + query.bind(id); + } + + oss << " " << clusterClause.get(); + oss << " GROUP BY t.id,a.id HAVING COUNT(DISTINCT c.id) = " << clusterIds.size() << ")"; + + query.where(oss.str()); + } + + return query; + } + + Wt::Dbo::Query createReleasesQuery(Wt::Dbo::Session& session, UserId userId, ScrobblingBackend backend, const std::vector& clusterIds) + { + auto query{ session.query("SELECT r.id from release r") + .join("track t ON t.release_id = r.id") + .join("listen l ON l.track_id = t.id") + .where("l.user_id = ?").bind(userId) + .where("l.backend = ?").bind(backend) }; + + if (!clusterIds.empty()) + { + std::ostringstream oss; + oss << "r.id IN (SELECT DISTINCT r.id FROM release r" + " INNER JOIN track t ON t.release_id = r.id" + " INNER JOIN cluster c ON c.id = t_c.cluster_id" + " INNER JOIN track_cluster t_c ON t_c.track_id = t.id"; + + WhereClause clusterClause; + for (ClusterId id : clusterIds) + { + clusterClause.Or(WhereClause("c.id = ?")); + query.bind(id); + } + + oss << " " << clusterClause.get(); + oss << " GROUP BY t.id HAVING COUNT(DISTINCT c.id) = " << clusterIds.size() << ")"; + + query.where(oss.str()); + } + + return query; + } + + Wt::Dbo::Query createTracksQuery(Wt::Dbo::Session& session, UserId userId, ArtistId artistId, ScrobblingBackend backend, const std::vector& clusterIds) + { + auto query{ session.query("SELECT t.id from track t") + .join("listen l ON l.track_id = t.id") + .where("l.user_id = ?").bind(userId) + .where("l.backend = ?").bind(backend) }; + + if (artistId.isValid()) + query.join("track_artist_link t_a_l ON t_a_l.track_id = t.id").where("t_a_l.artist_id = ?").bind(artistId); + + if (!clusterIds.empty()) + { + std::ostringstream oss; + oss << "t.id IN (SELECT DISTINCT t.id FROM track t" + " INNER JOIN track_cluster t_c ON t_c.track_id = t.id" + " INNER JOIN cluster c ON c.id = t_c.cluster_id"; + + WhereClause clusterClause; + for (auto id : clusterIds) + { + clusterClause.Or(WhereClause("c.id = ?")).bind(id.toString()); + query.bind(id); + } + + oss << " " << clusterClause.get(); + oss << " GROUP BY t.id HAVING COUNT(*) = " << clusterIds.size() << ")"; + + query.where(oss.str()); + } + + return query; + } + } + Listen::Listen(ObjectPtr user, ObjectPtr track, ScrobblingBackend backend, const Wt::WDateTime& dateTime) : _dateTime{ Wt::WDateTime::fromTime_t(dateTime.toTime_t()) } , _backend{ backend } @@ -212,7 +213,17 @@ namespace Database RangeResults Listen::getTopTracks(Session& session, UserId userId, ScrobblingBackend backend, const std::vector& clusterIds, std::optional range) { session.checkReadTransaction(); - auto query{ createTracksQuery(session.getDboSession(), userId, backend, clusterIds) + auto query{ createTracksQuery(session.getDboSession(), userId, ArtistId{}, backend, clusterIds) + .orderBy("COUNT(t.id) DESC") + .groupBy("t.id") }; + + return Utils::execQuery(query, range); + } + + RangeResults Listen::getTopTracks(Session& session, UserId userId, ArtistId artistId, ScrobblingBackend backend, const std::vector& clusterIds, std::optional range) + { + session.checkReadTransaction(); + auto query{ createTracksQuery(session.getDboSession(), userId, artistId, backend, clusterIds) .orderBy("COUNT(t.id) DESC") .groupBy("t.id") }; @@ -242,7 +253,7 @@ namespace Database RangeResults Listen::getRecentTracks(Session& session, UserId userId, ScrobblingBackend backend, const std::vector& clusterIds, std::optional range) { session.checkReadTransaction(); - auto query{ createTracksQuery(session.getDboSession(), userId, backend, clusterIds) + auto query{ createTracksQuery(session.getDboSession(), userId, ArtistId{}, backend, clusterIds) .groupBy("t.id").having("l.date_time = MAX(l.date_time)") .orderBy("l.date_time DESC") }; @@ -307,4 +318,3 @@ namespace Database .resultValue(); } } // namespace Database - diff --git a/src/libs/database/impl/Migration.cpp b/src/libs/database/impl/Migration.cpp index 6cff6ac2..59d20694 100644 --- a/src/libs/database/impl/Migration.cpp +++ b/src/libs/database/impl/Migration.cpp @@ -267,6 +267,31 @@ CREATE TABLE IF NOT EXISTS "track_backup" ( session.getDboSession().execute("UPDATE scan_settings SET scan_version = scan_version + 1"); } + void migrateFromV47(Session& session) + { + // release type, new way + session.getDboSession().execute("ALTER TABLE release DROP primary_type"); + session.getDboSession().execute("ALTER TABLE release DROP secondary_types"); + + session.getDboSession().execute(R"(CREATE TABLE IF NOT EXISTS "release_type" ( + "id" integer primary key autoincrement, + "version" integer not null, + "name" text not null))"); + + session.getDboSession().execute(R"(CREATE TABLE IF NOT EXISTS "release_release_type" ( + "release_type_id" bigint, + "release_id" bigint, + primary key ("release_type_id", "release_id"), + constraint "fk_release_release_type_key1" foreign key ("release_type_id") references "release_type" ("id") on delete cascade deferrable initially deferred, + constraint "fk_release_release_type_key2" foreign key ("release_id") references "release" ("id") on delete cascade deferrable initially deferred +))"); + session.getDboSession().execute(R"(CREATE INDEX "release_release_type_release_type" on "release_release_type" ("release_type_id"))"); + session.getDboSession().execute(R"(CREATE INDEX "release_release_type_release" on "release_release_type" ("release_id"))"); + + // Just increment the scan version of the settings to make the next scheduled scan rescan everything + session.getDboSession().execute("UPDATE scan_settings SET scan_version = scan_version + 1"); + } + void doDbMigration(Session& session) { static const std::string outdatedMsg{ "Outdated database, please rebuild it (delete the .db file and restart)" }; @@ -292,6 +317,7 @@ CREATE TABLE IF NOT EXISTS "track_backup" ( {44, migrateFromV44}, {45, migrateFromV45}, {46, migrateFromV46}, + {47, migrateFromV47}, }; { diff --git a/src/libs/database/impl/Migration.hpp b/src/libs/database/impl/Migration.hpp index 3c351bad..5717b96d 100644 --- a/src/libs/database/impl/Migration.hpp +++ b/src/libs/database/impl/Migration.hpp @@ -26,7 +26,7 @@ namespace Database class Session; using Version = std::size_t; - static constexpr Version LMS_DATABASE_VERSION{ 47 }; + static constexpr Version LMS_DATABASE_VERSION{ 48 }; class VersionInfo { public: diff --git a/src/libs/database/impl/Release.cpp b/src/libs/database/impl/Release.cpp index 9dcda60e..f56b028e 100644 --- a/src/libs/database/impl/Release.cpp +++ b/src/libs/database/impl/Release.cpp @@ -30,6 +30,7 @@ #include "SqlQuery.hpp" #include "EnumSetTraits.hpp" #include "IdTypeTraits.hpp" +#include "StringViewTraits.hpp" #include "Utils.hpp" namespace Database @@ -53,6 +54,13 @@ namespace Database query.join("track t ON t.release_id = r.id"); } + if (!params.releaseType.empty()) + { + query.join("release_release_type r_r_t ON r_r_t.release_id = r.id"); + query.join("release_type r_t ON r_t.id = r_r_t.release_type_id") + .where("r_t.name = ?").bind(params.releaseType); + } + if (params.writtenAfter.isValid()) query.where("t.file_last_write > ?").bind(params.writtenAfter); @@ -148,11 +156,6 @@ namespace Database query.where(oss.str()); } - if (params.primaryType) - query.where("primary_type = ?").bind(*params.primaryType); - if (!params.secondaryTypes.empty()) - query.where("secondary_type = ?").bind(params.secondaryTypes); - switch (params.sortMethod) { case ReleaseSortMethod::None: @@ -185,6 +188,36 @@ namespace Database } } + ReleaseType::ReleaseType(std::string_view name) + : _name{ std::string(name, 0 , _maxNameLength) } + { + } + + ReleaseType::pointer ReleaseType::create(Session& session, std::string_view name) + { + return session.getDboSession().add(std::unique_ptr {new ReleaseType{ name }}); + } + + ReleaseType::pointer ReleaseType::find(Session& session, ReleaseTypeId id) + { + session.checkReadTransaction(); + + return session.getDboSession() + .find() + .where("id = ?").bind(id) + .resultValue(); + } + + ReleaseType::pointer ReleaseType::find(Session& session, std::string_view name) + { + session.checkReadTransaction(); + + return session.getDboSession() + .find() + .where("name = ?").bind(name) + .resultValue(); + } + Release::Release(const std::string& name, const std::optional& MBID) : _name{ std::string(name, 0 , _maxNameLength) }, _MBID{ MBID ? MBID->getAsString() : "" } @@ -448,6 +481,16 @@ namespace Database return std::vector(res.begin(), res.end()); } + void Release::clearReleaseTypes() + { + _releaseTypes.clear(); + } + + void Release::addReleaseType(ObjectPtr releaseType) + { + _releaseTypes.insert(getDboPtr(releaseType)); + } + bool Release::hasVariousArtists() const { // TODO optimize @@ -459,6 +502,21 @@ namespace Database return _tracks.size(); } + std::vector> Release::getReleaseTypes() const + { + return std::vector>(_releaseTypes.begin(), _releaseTypes.end()); + } + + std::vector Release::getReleaseTypeNames() const + { + std::vector res; + + for (const auto& releaseType : _releaseTypes) + res.push_back(std::string{ releaseType->getName() }); + + return res; + } + std::chrono::milliseconds Release::getDuration() const { assert(session()); diff --git a/src/libs/database/impl/Session.cpp b/src/libs/database/impl/Session.cpp index 06ce0151..9079c664 100644 --- a/src/libs/database/impl/Session.cpp +++ b/src/libs/database/impl/Session.cpp @@ -82,6 +82,7 @@ namespace Database _session.mapClass("cluster_type"); _session.mapClass("listen"); _session.mapClass("release"); + _session.mapClass("release_type"); _session.mapClass("scan_settings"); _session.mapClass("starred_artist"); _session.mapClass("starred_release"); @@ -142,6 +143,7 @@ namespace Database _session.execute("CREATE INDEX IF NOT EXISTS release_name_idx ON release(name)"); _session.execute("CREATE INDEX IF NOT EXISTS release_name_nocase_idx ON release(name COLLATE NOCASE)"); _session.execute("CREATE INDEX IF NOT EXISTS release_mbid_idx ON release(mbid)"); + _session.execute("CREATE INDEX IF NOT EXISTS release_type_name_idx ON release_type(name)"); _session.execute("CREATE INDEX IF NOT EXISTS track_path_idx ON track(file_path)"); _session.execute("CREATE INDEX IF NOT EXISTS track_name_idx ON track(name)"); _session.execute("CREATE INDEX IF NOT EXISTS track_name_nocase_idx ON track(name COLLATE NOCASE)"); diff --git a/src/libs/database/impl/Track.cpp b/src/libs/database/impl/Track.cpp index 4811dc95..68124631 100644 --- a/src/libs/database/impl/Track.cpp +++ b/src/libs/database/impl/Track.cpp @@ -197,8 +197,7 @@ namespace Database return session.getDboSession().add(std::unique_ptr {new Track{ p }}); } - std::size_t - Track::getCount(Session& session) + std::size_t Track::getCount(Session& session) { session.checkReadTransaction(); diff --git a/src/libs/database/include/database/Artist.hpp b/src/libs/database/include/database/Artist.hpp index bbe03a64..24875565 100644 --- a/src/libs/database/include/database/Artist.hpp +++ b/src/libs/database/include/database/Artist.hpp @@ -82,7 +82,7 @@ namespace Database static std::size_t getCount(Session& session); static pointer find(Session& session, const UUID& MBID); static pointer find(Session& session, ArtistId id); - static std::vector find(Session& session, const std::string& name); // exact match on name field + static std::vector find(Session& session, std::string_view name); // exact match on name field static RangeResults find(Session& session, const FindParameters& parameters); static void find(Session& session, const FindParameters& parameters, std::function func); static RangeResults findIds(Session& session, const FindParameters& parameters); diff --git a/src/libs/database/include/database/Listen.hpp b/src/libs/database/include/database/Listen.hpp index 20e90b3b..b745112c 100644 --- a/src/libs/database/include/database/Listen.hpp +++ b/src/libs/database/include/database/Listen.hpp @@ -68,6 +68,7 @@ namespace Database static RangeResults getTopArtists(Session& session, UserId userId, ScrobblingBackend backend, const std::vector& clusterIds, std::optional linkType, std::optional range = std::nullopt); static RangeResults getTopReleases(Session& session, UserId userId, ScrobblingBackend backend, const std::vector& clusterIds, std::optional range = std::nullopt); static RangeResults getTopTracks(Session& session, UserId userId, ScrobblingBackend backend, const std::vector& clusterIds, std::optional range = std::nullopt); + static RangeResults getTopTracks(Session& session, UserId userId, ArtistId artistId, ScrobblingBackend backend, const std::vector& clusterIds, std::optional range = std::nullopt); static RangeResults getRecentArtists(Session& session, UserId userId, ScrobblingBackend backend, const std::vector& clusterIds, std::optional linkType, std::optional range = std::nullopt); static RangeResults getRecentReleases(Session& session, UserId userId, ScrobblingBackend backend, const std::vector& clusterIds, std::optional range = std::nullopt); diff --git a/src/libs/database/include/database/Release.hpp b/src/libs/database/include/database/Release.hpp index ab448472..b91c4ad4 100644 --- a/src/libs/database/include/database/Release.hpp +++ b/src/libs/database/include/database/Release.hpp @@ -21,6 +21,8 @@ #include #include +#include +#include #include #include @@ -30,6 +32,7 @@ #include "database/ClusterId.hpp" #include "database/Object.hpp" #include "database/ReleaseId.hpp" +#include "database/ReleaseTypeId.hpp" #include "database/Types.hpp" #include "database/UserId.hpp" #include "utils/EnumSet.hpp" @@ -37,7 +40,6 @@ namespace Database { - class Artist; class Cluster; class ClusterType; @@ -46,6 +48,34 @@ namespace Database class Track; class User; + class ReleaseType final : public Object + { + public: + ReleaseType() = default; + static pointer find(Session& session, ReleaseTypeId id); + static pointer find(Session& session, std::string_view name); + + // Accessors + std::string_view getName() const { return _name; } + + template + void persist(Action& a) + { + Wt::Dbo::field(a, _name, "name"); + Wt::Dbo::hasMany(a, _releases, Wt::Dbo::ManyToMany, "release_release_type", "", Wt::Dbo::OnDeleteCascade); + } + + private: + static constexpr std::size_t _maxNameLength{ 128 }; + + friend class Session; + ReleaseType(std::string_view name); + static pointer create(Session& session, std::string_view name); + + std::string _name; + Wt::Dbo::collection> _releases; // releases that match this type + }; + class Release final : public Object { public: @@ -62,9 +92,8 @@ namespace Database ArtistId artist; // only releases that involved this user EnumSet trackArtistLinkTypes; // and for these link types EnumSet excludedTrackArtistLinkTypes; // but not for these link types - std::optional primaryType; // if set, matching this primary type - EnumSet secondaryTypes; // Matching all this (if any) - + std::string releaseType; // If set, albums that has this release type + FindParameters& setClusters(const std::vector& _clusters) { clusters = _clusters; return *this; } FindParameters& setKeywords(const std::vector& _keywords) { keywords = _keywords; return *this; } FindParameters& setSortMethod(ReleaseSortMethod _sortMethod) { sortMethod = _sortMethod; return *this; } @@ -79,6 +108,7 @@ namespace Database excludedTrackArtistLinkTypes = _excludedTrackArtistLinkTypes; return *this; } + FindParameters& setReleaseType(std::string_view _releaseType) { releaseType = _releaseType; return *this; } }; Release() = default; @@ -116,18 +146,18 @@ namespace Database std::vector getDiscs() const; std::chrono::milliseconds getDuration() const; Wt::WDateTime getLastWritten() const; - std::optional getPrimaryType() const { return _primaryType; } - EnumSet getSecondaryTypes() const { return _secondaryTypes; } std::string_view getArtistDisplayName() const { return _artistDisplayName; } std::size_t getTracksCount() const; + std::vector> getReleaseTypes() const; + std::vector getReleaseTypeNames() const; // Setters void setName(std::string_view name) { _name = name; } void setMBID(const std::optional& mbid) { _MBID = mbid ? mbid->getAsString() : ""; } void setTotalDisc(std::optional totalDisc) { _totalDisc = totalDisc; } - void setPrimaryType(std::optional type) { _primaryType = type; } - void setSecondaryTypes(EnumSet types) { _secondaryTypes = types; } void setArtistDisplayName(std::string_view name) { _artistDisplayName = name; } + void clearReleaseTypes(); + void addReleaseType(ObjectPtr releaseType); // Get the artists of this release std::vector> getArtists(TrackArtistLinkType type = TrackArtistLinkType::Artist) const; @@ -135,17 +165,15 @@ namespace Database bool hasVariousArtists() const; std::vector getSimilarReleases(std::optional offset = {}, std::optional count = {}) const; - template void persist(Action& a) { Wt::Dbo::field(a, _name, "name"); Wt::Dbo::field(a, _MBID, "mbid"); Wt::Dbo::field(a, _totalDisc, "total_disc"); - Wt::Dbo::field(a, _primaryType, "primary_type"); - Wt::Dbo::field(a, _secondaryTypes, "secondary_types"); Wt::Dbo::field(a, _artistDisplayName, "artist_display_name"); Wt::Dbo::hasMany(a, _tracks, Wt::Dbo::ManyToOne, "release"); + Wt::Dbo::hasMany(a, _releaseTypes, Wt::Dbo::ManyToMany, "release_release_type", "", Wt::Dbo::OnDeleteCascade); } private: @@ -160,13 +188,10 @@ namespace Database std::string _name; std::string _MBID; std::optional _totalDisc{}; - std::optional _primaryType; - EnumSet _secondaryTypes; std::string _artistDisplayName; - Wt::Dbo::collection> _tracks; // Tracks in the release + Wt::Dbo::collection> _tracks; // Tracks in the release + Wt::Dbo::collection> _releaseTypes; // Release types }; } // namespace Database - - diff --git a/src/libs/database/include/database/ReleaseTypeId.hpp b/src/libs/database/include/database/ReleaseTypeId.hpp new file mode 100644 index 00000000..2559c4e5 --- /dev/null +++ b/src/libs/database/include/database/ReleaseTypeId.hpp @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2021 Emeric Poupon + * + * This file is part of LMS. + * + * LMS is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * LMS is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with LMS. If not, see . + */ + +#pragma once + +#include "database/IdType.hpp" + +LMS_DECLARE_IDTYPE(ReleaseTypeId) + diff --git a/src/libs/database/include/database/TrackList.hpp b/src/libs/database/include/database/TrackList.hpp index fee3386d..e7bc780c 100644 --- a/src/libs/database/include/database/TrackList.hpp +++ b/src/libs/database/include/database/TrackList.hpp @@ -88,10 +88,6 @@ namespace Database { std::vector> getEntries(std::optional range = {}) const; ObjectPtr getEntryByTrackAndDateTime(ObjectPtr track, const Wt::WDateTime& dateTime) const; - RangeResults> getArtists(const std::vector& clusters, std::optional linkType, ArtistSortMethod sortMethod, std::optional range, bool& moreResults) const; - RangeResults> getReleases(const std::vector& clusters, std::optional range, bool& moreResults) const; - RangeResults> getTracks(const std::vector& clusters, std::optional range, bool& moreResults) const; - std::vector getTrackIds() const; std::chrono::milliseconds getDuration() const; diff --git a/src/libs/database/include/database/Types.hpp b/src/libs/database/include/database/Types.hpp index fc261058..14d96dee 100644 --- a/src/libs/database/include/database/Types.hpp +++ b/src/libs/database/include/database/Types.hpp @@ -220,30 +220,5 @@ namespace Database Playlist, // user controlled playlists Internal, // internal usage (current playqueue, history, ...) }; - - // as defined in https://musicbrainz.org/doc/Release_Group/Type - enum class ReleaseTypePrimary - { - Album, - Single, - EP, - Broadcast, - Other, - }; - - enum class ReleaseTypeSecondary - { - Compilation, - Soundtrack, - Spokenword, - Interview, - Audiobook, - AudioDrama, - Live, - Remix, - DJMix, - Mixtape_Street, - Demo, - }; } diff --git a/src/libs/database/test/Common.hpp b/src/libs/database/test/Common.hpp index 4da03734..d052b2ff 100644 --- a/src/libs/database/test/Common.hpp +++ b/src/libs/database/test/Common.hpp @@ -40,7 +40,7 @@ #include "database/User.hpp" template -class ScopedEntity +class [[nodiscard]] ScopedEntity { public: using IdType = typename T::IdType; diff --git a/src/libs/database/test/Listen.cpp b/src/libs/database/test/Listen.cpp index 6d075ced..e011b228 100644 --- a/src/libs/database/test/Listen.cpp +++ b/src/libs/database/test/Listen.cpp @@ -438,6 +438,47 @@ TEST_F(DatabaseFixture, Listen_getTopTracks) } } + +TEST_F(DatabaseFixture, Listen_getTopTracks_artist) +{ + ScopedTrack track{ session, "MyTrack" }; + ScopedUser user{ session, "MyUser" }; + ScopedArtist artist{ session, "MyArtist" }; + const Wt::WDateTime dateTime{ Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1} }; + + { + auto transaction{ session.createReadTransaction() }; + + auto tracks{ Listen::getTopTracks(session, user->getId(), artist->getId(), ScrobblingBackend::Internal, {}) }; + EXPECT_EQ(tracks.moreResults, false); + ASSERT_EQ(tracks.results.size(), 0); + } + + ScopedListen listen{ session, user.lockAndGet(), track.lockAndGet(), ScrobblingBackend::Internal, dateTime }; + + { + auto transaction{ session.createReadTransaction() }; + + auto tracks{ Listen::getTopTracks(session, user->getId(), artist->getId(), ScrobblingBackend::Internal, {}) }; + EXPECT_EQ(tracks.moreResults, false); + ASSERT_EQ(tracks.results.size(), 0); + } + + { + auto transaction{ session.createWriteTransaction() }; + TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist); + } + + { + auto transaction{ session.createReadTransaction() }; + + auto tracks{ Listen::getTopTracks(session, user->getId(), artist->getId(), ScrobblingBackend::Internal, {}) }; + EXPECT_EQ(tracks.moreResults, false); + ASSERT_EQ(tracks.results.size(), 1); + EXPECT_EQ(tracks.results[0], track.getId()); + } +} + TEST_F(DatabaseFixture, Listen_getTopTrack_multi) { ScopedTrack track1{ session, "MyTrack1" }; diff --git a/src/libs/database/test/Release.cpp b/src/libs/database/test/Release.cpp index dec592df..52b736fd 100644 --- a/src/libs/database/test/Release.cpp +++ b/src/libs/database/test/Release.cpp @@ -20,6 +20,7 @@ #include "Common.hpp" using namespace Database; +using ScopedReleaseType = ScopedEntity; TEST_F(DatabaseFixture, Release) { @@ -559,26 +560,78 @@ TEST_F(DatabaseFixture, Release_getDiscCount) } } +TEST_F(DatabaseFixture, ReleaseType) +{ + { + auto transaction{ session.createReadTransaction() }; + ReleaseType::pointer res{ ReleaseType::find(session, "album") }; + EXPECT_EQ(res, ReleaseType::pointer{}); + } + + ScopedReleaseType releaseType{ session, "album" }; + + { + auto transaction{ session.createReadTransaction() }; + ReleaseType::pointer res{ ReleaseType::find(session, "album") }; + EXPECT_EQ(res, releaseType.get()); + } +} + TEST_F(DatabaseFixture, Release_releaseType) { ScopedRelease release{ session, "MyRelease" }; { auto transaction{ session.createReadTransaction() }; - EXPECT_EQ(release.get()->getPrimaryType(), std::nullopt); - EXPECT_EQ(release.get()->getSecondaryTypes(), EnumSet {}); + EXPECT_EQ(release.get()->getReleaseTypes().size(), 0); } + ScopedReleaseType releaseType{ session, "album" }; + { auto transaction{ session.createWriteTransaction() }; - release.get().modify()->setPrimaryType({ ReleaseTypePrimary::Album }); - release.get().modify()->setSecondaryTypes({ ReleaseTypeSecondary::Compilation }); + release.get().modify()->addReleaseType(releaseType.get()); } { auto transaction{ session.createReadTransaction() }; - EXPECT_EQ(release.get()->getPrimaryType(), ReleaseTypePrimary::Album); - EXPECT_TRUE(release.get()->getSecondaryTypes().contains(ReleaseTypeSecondary::Compilation)); + + const auto releaseTypes{ release.get()->getReleaseTypes() }; + ASSERT_EQ(releaseTypes.size(), 1); + EXPECT_EQ(releaseTypes.front()->getId(), releaseType.getId()); + + const auto releaseTypeNames{ release.get()->getReleaseTypeNames() }; + ASSERT_EQ(releaseTypeNames.size(), 1); + EXPECT_EQ(releaseTypeNames.front(), "album"); + } +} + +TEST_F(DatabaseFixture, Release_find_releaseType) +{ + ScopedRelease release{ session, "MyRelease" }; + + { + auto transaction{ session.createReadTransaction() }; + auto releases{ Release::find(session, Release::FindParameters{}.setReleaseType("Foo")).results }; + EXPECT_EQ(releases.size(), 0); + } + + ScopedReleaseType releaseType{ session, "album" }; + + { + auto transaction{ session.createWriteTransaction() }; + release.get().modify()->addReleaseType(releaseType.get()); + } + + { + auto transaction{ session.createReadTransaction() }; + + auto releases{ Release::find(session, Release::FindParameters{}.setReleaseType("Foo")).results }; + EXPECT_EQ(releases.size(), 0); + + releases = Release::find(session, Release::FindParameters{}.setReleaseType("album")).results; + ASSERT_EQ(releases.size(), 1); + EXPECT_EQ(releases.front()->getId(), release.getId()); } } diff --git a/src/libs/metadata/impl/AvFormatParser.cpp b/src/libs/metadata/impl/AvFormatParser.cpp index dc9aee4e..6784843d 100644 --- a/src/libs/metadata/impl/AvFormatParser.cpp +++ b/src/libs/metadata/impl/AvFormatParser.cpp @@ -226,15 +226,15 @@ namespace MetaData { track.recordingMBID = UUID::fromString(value); } - else if (std::find(std::cbegin(_extraTags), std::cend(_extraTags), tag) != std::cend(_extraTags)) + else if (std::find(std::cbegin(_userExtraTags), std::cend(_userExtraTags), tag) != std::cend(_userExtraTags)) { const std::vector tagValues{ StringUtils::splitString(value, "/,;") }; if (!tagValues.empty()) { - std::set values; + std::vector values; std::transform(std::cbegin(tagValues), std::cend(tagValues), std::inserter(values, std::begin(values)), [](std::string_view v) { return std::string{ v }; }); - track.tags[tag] = std::move(values); + track.userExtraTags[tag] = std::move(values); } } } diff --git a/src/libs/metadata/impl/TagLibParser.cpp b/src/libs/metadata/impl/TagLibParser.cpp index 62f1ab1e..49ba3000 100644 --- a/src/libs/metadata/impl/TagLibParser.cpp +++ b/src/libs/metadata/impl/TagLibParser.cpp @@ -214,12 +214,7 @@ namespace MetaData } } - release->primaryType = getPropertyValueFirstMatchAs(tags, { "MUSICBRAINZ_ALBUMTYPE", "RELEASETYPE", "MUSICBRAINZ ALBUM TYPE", "MUSICBRAINZ/ALBUM TYPE" }); - if (release->primaryType) - { - const auto secondaryTypes{ getPropertyValuesFirstMatchAs(tags, {"MUSICBRAINZ_ALBUMTYPE", "RELEASETYPE", "MUSICBRAINZ ALBUM TYPE", "MUSICBRAINZ/ALBUM TYPE"}) }; - release->secondaryTypes.assign(std::cbegin(secondaryTypes), std::cend(secondaryTypes)); - } + release->releaseTypes = getPropertyValuesFirstMatchAs(tags, { "MUSICBRAINZ_ALBUMTYPE", "RELEASETYPE", "MUSICBRAINZ ALBUM TYPE", "MUSICBRAINZ/ALBUM TYPE" }); return release; } @@ -368,18 +363,18 @@ namespace MetaData track.replayGain = StringUtils::readAs(value); else if (tag == "ARTIST") track.artistDisplayName = value; - else if (std::find(std::cbegin(_extraTags), std::cend(_extraTags), tag) != std::cend(_extraTags)) + else if (std::find(std::cbegin(_userExtraTags), std::cend(_userExtraTags), tag) != std::cend(_userExtraTags)) { - std::set tagValues; + std::vector tagValues; for (std::string_view valueList : values) { const std::vector splittedValues{ splitAndTrimString(valueList, "/,;") }; // handle possibily bad split tags for (std::string_view value : splittedValues) - tagValues.insert(std::string{ value }); + tagValues.push_back(std::string{ value }); } if (!tagValues.empty()) - track.tags[tag] = std::move(tagValues); + track.userExtraTags[tag] = std::move(tagValues); } } diff --git a/src/libs/metadata/impl/Utils.cpp b/src/libs/metadata/impl/Utils.cpp index c821959e..fb8f3f02 100644 --- a/src/libs/metadata/impl/Utils.cpp +++ b/src/libs/metadata/impl/Utils.cpp @@ -27,142 +27,91 @@ namespace MetaData::Utils { - Wt::WDate - parseDate(std::string_view dateStr) - { - static constexpr const char* formats[] - { - "%Y-%m-%d", - "%Y/%m/%d", - }; + Wt::WDate parseDate(std::string_view dateStr) + { + static constexpr const char* formats[] + { + "%Y-%m-%d", + "%Y/%m/%d", + }; - for (const char* format : formats) - { - std::tm tm = {}; - std::istringstream ss {std::string {dateStr}}; // TODO, remove extra copy here - ss >> std::get_time(&tm, format); - if (ss.fail()) - continue; + for (const char* format : formats) + { + std::tm tm = {}; + std::istringstream ss{ std::string {dateStr} }; // TODO, remove extra copy here + ss >> std::get_time(&tm, format); + if (ss.fail()) + continue; - const Wt::WDate res - { - tm.tm_year + 1900, // years since 1900 - tm.tm_mon + 1, // months since January – [0, 11] - tm.tm_mday ? tm.tm_mday : 1 // day of the month – [1, 31] - }; - if (!res.isValid()) - continue; + const Wt::WDate res + { + tm.tm_year + 1900, // years since 1900 + tm.tm_mon + 1, // months since January – [0, 11] + tm.tm_mday ? tm.tm_mday : 1 // day of the month – [1, 31] + }; + if (!res.isValid()) + continue; - return res; - } + return res; + } - return {}; - } + return {}; + } - std::string_view - readStyleToString(ParserReadStyle readStyle) - { - switch (readStyle) - { - case ParserReadStyle::Fast: return "fast"; - case ParserReadStyle::Average: return "average"; - case ParserReadStyle::Accurate: return "accurate"; - } + std::string_view readStyleToString(ParserReadStyle readStyle) + { + switch (readStyle) + { + case ParserReadStyle::Fast: return "fast"; + case ParserReadStyle::Average: return "average"; + case ParserReadStyle::Accurate: return "accurate"; + } - throw LmsException {"Unknown read style"}; - } + throw LmsException{ "Unknown read style" }; + } - PerformerArtist - extractPerformerAndRole(std::string_view entry) - { - std::string_view artistName; - std::string_view role; + PerformerArtist extractPerformerAndRole(std::string_view entry) + { + std::string_view artistName; + std::string_view role; - std::size_t roleBegin {}; - std::size_t roleEnd {}; - std::size_t count {}; + std::size_t roleBegin{}; + std::size_t roleEnd{}; + std::size_t count{}; - for (std::size_t i {}; i < entry.size(); ++i) - { - std::size_t currentIndex {entry.size() - i - 1}; - const char c {entry[currentIndex]}; + for (std::size_t i{}; i < entry.size(); ++i) + { + std::size_t currentIndex{ entry.size() - i - 1 }; + const char c{ entry[currentIndex] }; - if (std::isspace(c)) - continue; + if (std::isspace(c)) + continue; - if (c == ')') - { - if (count++ == 0) - roleEnd = currentIndex; - } - else if (c == '(') - { - if (count == 0) - break; + if (c == ')') + { + if (count++ == 0) + roleEnd = currentIndex; + } + else if (c == '(') + { + if (count == 0) + break; - if (--count == 0) - { - roleBegin = currentIndex + 1; - role = StringUtils::stringTrim(entry.substr(roleBegin, roleEnd - roleBegin)); - artistName = StringUtils::stringTrim(entry.substr(0, currentIndex)); - break; - } - } - else if (count == 0) - break; - } + if (--count == 0) + { + roleBegin = currentIndex + 1; + role = StringUtils::stringTrim(entry.substr(roleBegin, roleEnd - roleBegin)); + artistName = StringUtils::stringTrim(entry.substr(0, currentIndex)); + break; + } + } + else if (count == 0) + break; + } - if (!roleEnd || !roleBegin) - artistName = StringUtils::stringTrim(entry); - - return PerformerArtist {Artist {artistName}, std::string {role}}; - } -} - -namespace StringUtils -{ - static bool iequals(std::string_view a, std::string_view b) - { - return std::equal(std::cbegin(a), std::cend(a), - std::cbegin(b), std::cend(b), - [](char a, char b) { return tolower(a) == tolower(b);} - ); - } - - template<> - std::optional readAs(std::string_view str) - { - str = stringTrim(str); - - if (iequals(str, "album")) - return MetaData::Release::PrimaryType::Album; - else if (iequals(str, "single")) - return MetaData::Release::PrimaryType::Single; - else if (iequals(str, "EP")) - return MetaData::Release::PrimaryType::EP; - else if (iequals(str, "broadcast")) - return MetaData::Release::PrimaryType::Broadcast; - else if (iequals(str, "other")) - return MetaData::Release::PrimaryType::Other; - - return std::nullopt; - } - - template<> - std::optional readAs(std::string_view str) - { - str = stringTrim(str); - - if (iequals(str, "compilation")) - return MetaData::Release::SecondaryType::Compilation; - else if (iequals(str, "soundtrack")) - return MetaData::Release::SecondaryType::Soundtrack; - else if (iequals(str, "live")) - return MetaData::Release::SecondaryType::Live; - else if (iequals(str, "demo")) - return MetaData::Release::SecondaryType::Demo; - - return std::nullopt; - } -} + if (!roleEnd || !roleBegin) + artistName = StringUtils::stringTrim(entry); + return PerformerArtist{ Artist {artistName}, std::string {role} }; + } +} \ No newline at end of file diff --git a/src/libs/metadata/impl/Utils.hpp b/src/libs/metadata/impl/Utils.hpp index 8c80cc14..e1de14b8 100644 --- a/src/libs/metadata/impl/Utils.hpp +++ b/src/libs/metadata/impl/Utils.hpp @@ -39,13 +39,3 @@ namespace MetaData::Utils // format is "artist name (role)" PerformerArtist extractPerformerAndRole(std::string_view entry); } - -namespace StringUtils -{ - template<> - std::optional readAs(std::string_view str); - - template<> - std::optional readAs(std::string_view str); -} - diff --git a/src/libs/metadata/include/metadata/IParser.hpp b/src/libs/metadata/include/metadata/IParser.hpp index ce09f4a7..2f4399b5 100644 --- a/src/libs/metadata/include/metadata/IParser.hpp +++ b/src/libs/metadata/include/metadata/IParser.hpp @@ -23,18 +23,16 @@ #include #include #include -#include #include #include #include #include -#include "utils/EnumSet.hpp" #include "utils/UUID.hpp" namespace MetaData { - using Tags = std::map /* values */>; + using Tags = std::map /* values */>; // Very simplified version of https://musicbrainz.org/doc/MusicBrainz_Database/Schema @@ -52,43 +50,17 @@ namespace MetaData struct Release { - // see https://musicbrainz.org/doc/Release_Group/Type - enum class PrimaryType - { - Album, - Single, - EP, - Broadcast, - Other - }; - - enum class SecondaryType - { - Compilation, - Soundtrack, - Spokenword, - Interview, - Audiobook, - AudioDrama, - Live, - Remix, - DJMix, - Mixtape_Street, - Demo, - }; - std::optional mbid; std::string name; std::string artistDisplayName; std::vector artists; std::optional mediumCount; - std::optional primaryType; - EnumSet secondaryTypes; + std::vector releaseTypes; }; struct Medium { - std::string type; + std::string type; // CD, etc. std::string name; std::optional release; std::optional position; // in release @@ -103,7 +75,11 @@ namespace MetaData std::string title; std::optional medium; std::optional position; // in medium - Tags tags; + std::vector grouping; + std::vector genres; + std::vector moods; + std::vector languages; + Tags userExtraTags; std::chrono::milliseconds duration{}; std::size_t bitrate{}; Wt::WDate date; @@ -131,10 +107,10 @@ namespace MetaData virtual std::optional parse(const std::filesystem::path& p, bool debug = false) = 0; - void setExtraTags(const std::vector& extraTags) { _extraTags = std::set(extraTags.cbegin(), extraTags.cend()); } + void setUserExtraTags(const std::vector& extraTags) { _userExtraTags = std::vector(extraTags.cbegin(), extraTags.cend()); } protected: - std::set _extraTags; + std::vector _userExtraTags; }; enum class ParserType @@ -151,4 +127,3 @@ namespace MetaData }; std::unique_ptr createParser(ParserType parserType, ParserReadStyle parserReadStyle); } // namespace MetaData - diff --git a/src/libs/metadata/test/Utils.cpp b/src/libs/metadata/test/Utils.cpp index 1cc0e69c..41b9ee9e 100644 --- a/src/libs/metadata/test/Utils.cpp +++ b/src/libs/metadata/test/Utils.cpp @@ -115,60 +115,3 @@ TEST(MetaData, extractPerformerAndRole) EXPECT_EQ(performer.role, testCase.expectedRole) << " str was '" << testCase.str << "'"; } } - -TEST(MetaData, primaryReleaseTypes) -{ - using namespace MetaData; - - struct TestCase - { - std::string str; - std::optional result; - } testCases [] - { - { "", std::nullopt }, - { "album", Release::PrimaryType::Album }, - { "Album", Release::PrimaryType::Album }, - { " Album", Release::PrimaryType::Album }, - { "Album ", Release::PrimaryType::Album }, - { "ep", Release::PrimaryType::EP }, - { " ep ", Release::PrimaryType::EP }, - { "broadcast", Release::PrimaryType::Broadcast }, - { "single", Release::PrimaryType::Single }, - { "other", Release::PrimaryType::Other }, - }; - - for (const TestCase& testCase : testCases) - { - std::optional parsed {StringUtils::readAs(testCase.str)}; - - EXPECT_EQ(parsed, testCase.result) << " str was '" << testCase.str << "'"; - } -} - -TEST(MetaData, secondaryReleaseTypes) -{ - using namespace MetaData; - - struct TestCase - { - std::string str; - std::optional result; - } testCases [] - { - { "", std::nullopt }, - { "compilation", Release::SecondaryType::Compilation }, - { " compilation ", Release::SecondaryType::Compilation }, - { "soundtrack", Release::SecondaryType::Soundtrack }, - { "live", Release::SecondaryType::Live }, - { "demo", Release::SecondaryType::Demo }, - }; - - for (const TestCase& testCase : testCases) - { - std::optional parsed {StringUtils::readAs(testCase.str)}; - - EXPECT_EQ(parsed, testCase.result) << " str was '" << testCase.str << "'"; - } -} - diff --git a/src/libs/services/cover/impl/CoverService.cpp b/src/libs/services/cover/impl/CoverService.cpp index 14bb4f99..b2202249 100644 --- a/src/libs/services/cover/impl/CoverService.cpp +++ b/src/libs/services/cover/impl/CoverService.cpp @@ -19,6 +19,8 @@ #include "CoverService.hpp" +#include + #include "av/IAudioFile.hpp" #include "database/Db.hpp" @@ -30,13 +32,13 @@ #include "image/IRawImage.hpp" #include "utils/IConfig.hpp" #include "utils/ILogger.hpp" +#include "utils/Path.hpp" #include "utils/Random.hpp" #include "utils/String.hpp" #include "utils/Utils.hpp" namespace Cover { - namespace { struct TrackInfo @@ -85,6 +87,19 @@ namespace Cover return res; } + std::vector constructArtistFileNames() + { + std::vector res; + + Service::get()->visitStrings("artist-image-file-names", + [&res](std::string_view fileName) + { + res.emplace_back(fileName); + }, { "artist" }); + + return res; + } + bool isFileSupported(const std::filesystem::path& file, const std::vector& extensions) { return (std::find(std::cbegin(extensions), std::cend(extensions), file.extension()) != std::cend(extensions)); @@ -106,7 +121,7 @@ namespace Cover , _maxCacheSize{ Service::get()->getULong("cover-max-cache-size", 30) * 1000 * 1000 } , _maxFileSize{ Service::get()->getULong("cover-max-file-size", 10) * 1000 * 1000 } , _preferredFileNames{ constructPreferredFileNames() } - + , _artistFileNames{ constructArtistFileNames() } { setJpegQuality(Service::get()->getULong("cover-jpeg-quality", 75)); @@ -196,7 +211,7 @@ namespace Cover } } - std::unique_ptr CoverService::getFromDirectory(const std::filesystem::path& directory, ImageSize width) const + std::unique_ptr CoverService::getFromDirectory(const std::filesystem::path& directory, ImageSize width, const std::vector& preferredFileNames, bool allowPickRandom) const { const std::multimap coverPaths{ getCoverPaths(directory) }; @@ -216,19 +231,21 @@ namespace Cover std::unique_ptr image; - for (std::string_view filename : _preferredFileNames) + for (std::string_view filename : preferredFileNames) { image = tryLoadImageFromFilename(filename); if (image) return image; } - // Just pick one - for (const auto& [filename, coverPath] : coverPaths) + if (allowPickRandom) { - image = getFromCoverFile(coverPath, width); - if (image) - return image; + for (const auto& [filename, coverPath] : coverPaths) + { + image = getFromCoverFile(coverPath, width); + if (image) + return image; + } } return image; @@ -269,7 +286,7 @@ namespace Cover if (std::filesystem::file_size(filePath, ec) > _maxFileSize && !ec) { - LMS_LOG(COVER, INFO, "Cover file '" << filePath.string() << " is too big (" << std::filesystem::file_size(filePath, ec) << "), limit is " << _maxFileSize); + LMS_LOG(COVER, INFO, "Image file '" << filePath.string() << " is too big (" << std::filesystem::file_size(filePath, ec) << "), limit is " << _maxFileSize); return false; } @@ -341,7 +358,7 @@ namespace Cover if (!cover && trackInfo->isMultiDisc) { if (trackInfo->trackPath.parent_path().has_parent_path()) - cover = getFromDirectory(trackInfo->trackPath.parent_path().parent_path(), width); + cover = getFromDirectory(trackInfo->trackPath.parent_path().parent_path(), width, _preferredFileNames, true); } } @@ -389,7 +406,7 @@ namespace Cover if (const std::optional releaseInfo{ getReleaseInfo() }) { - cover = getFromDirectory(releaseInfo->releaseDirectory, width); + cover = getFromDirectory(releaseInfo->releaseDirectory, width, _preferredFileNames, true); if (!cover) cover = getFromTrack(session, releaseInfo->firstTrackId, width, false /* no release fallback */); } @@ -400,6 +417,50 @@ namespace Cover return cover; } + std::shared_ptr CoverService::getFromArtist(Database::ArtistId artistId, ImageSize width) + { + using namespace Database; + const CacheEntryDesc cacheEntryDesc{ artistId, width }; + + std::shared_ptr artistImage{ loadFromCache(cacheEntryDesc) }; + if (artistImage) + return artistImage; + + std::set parentPaths; + { + Session& session{ _db.getTLSSession() }; + auto transaction{ session.createReadTransaction() }; + + Track::find(session, Track::FindParameters{}.setArtist(artistId), [&](const Track::pointer& track) + { + parentPaths.insert(track->getPath().parent_path()); + }); + } + + if (parentPaths.size() == 1) + artistImage = getFromDirectory(parentPaths.begin()->parent_path(), width, _artistFileNames, false); + else if (parentPaths.size() > 1) + { + const std::filesystem::path longestCommonPath{ PathUtils::getLongestCommonPath(std::cbegin(parentPaths), std::cend(parentPaths)) }; + artistImage = getFromDirectory(longestCommonPath, width, _artistFileNames, false); + } + + if (!artistImage) + { + for (const std::filesystem::path& parentPath : parentPaths) + { + artistImage = getFromDirectory(parentPath, width, _artistFileNames, false); + if (artistImage) + break; + } + } + + if (artistImage) + saveToCache(cacheEntryDesc, artistImage); + + return artistImage; + } + void CoverService::flushCache() { std::unique_lock lock{ _cacheMutex }; diff --git a/src/libs/services/cover/impl/CoverService.hpp b/src/libs/services/cover/impl/CoverService.hpp index 248245f7..d5755411 100644 --- a/src/libs/services/cover/impl/CoverService.hpp +++ b/src/libs/services/cover/impl/CoverService.hpp @@ -47,7 +47,7 @@ namespace Cover { struct CacheEntryDesc { - std::variant id; + std::variant id; std::size_t size; bool operator==(const CacheEntryDesc& other) const @@ -92,6 +92,7 @@ namespace Cover private: std::shared_ptr getFromTrack(Database::TrackId trackId, Image::ImageSize width) override; std::shared_ptr getFromRelease(Database::ReleaseId releaseId, Image::ImageSize width) override; + std::shared_ptr getFromArtist(Database::ArtistId artistId, Image::ImageSize width) override; std::shared_ptr getDefault(Image::ImageSize width) override; void flushCache() override; void setJpegQuality(unsigned quality) override; @@ -102,7 +103,7 @@ namespace Cover std::unique_ptr getFromTrack(const std::filesystem::path& path, Image::ImageSize width) const; std::multimap getCoverPaths(const std::filesystem::path& directoryPath) const; - std::unique_ptr getFromDirectory(const std::filesystem::path& directory, Image::ImageSize width) const; + std::unique_ptr getFromDirectory(const std::filesystem::path& directory, Image::ImageSize width, const std::vector& preferredFileNames, bool allowPickRandom) const; std::unique_ptr getFromSameNamedFile(const std::filesystem::path& filePath, Image::ImageSize width) const; bool checkCoverFile(const std::filesystem::path& directoryPath) const; @@ -124,6 +125,7 @@ namespace Cover static inline const std::vector _fileExtensions{ ".jpg", ".jpeg", ".png", ".bmp" }; // TODO parametrize const std::size_t _maxFileSize; const std::vector _preferredFileNames; + const std::vector _artistFileNames; unsigned _jpegQuality; }; diff --git a/src/libs/services/cover/include/services/cover/ICoverService.hpp b/src/libs/services/cover/include/services/cover/ICoverService.hpp index abe35fee..4269087e 100644 --- a/src/libs/services/cover/include/services/cover/ICoverService.hpp +++ b/src/libs/services/cover/include/services/cover/ICoverService.hpp @@ -22,6 +22,7 @@ #include #include +#include "database/ArtistId.hpp" #include "database/ReleaseId.hpp" #include "database/TrackId.hpp" #include "image/IEncodedImage.hpp" @@ -40,6 +41,7 @@ namespace Cover virtual std::shared_ptr getFromTrack(Database::TrackId trackId, Image::ImageSize width) = 0; virtual std::shared_ptr getFromRelease(Database::ReleaseId releaseId, Image::ImageSize width) = 0; + virtual std::shared_ptr getFromArtist(Database::ArtistId artistId, Image::ImageSize width) = 0; virtual std::shared_ptr getDefault(Image::ImageSize width) = 0; diff --git a/src/libs/services/scanner/impl/ScanStepScanFiles.cpp b/src/libs/services/scanner/impl/ScanStepScanFiles.cpp index 28e500bc..06edef62 100644 --- a/src/libs/services/scanner/impl/ScanStepScanFiles.cpp +++ b/src/libs/services/scanner/impl/ScanStepScanFiles.cpp @@ -114,84 +114,29 @@ namespace Scanner return artists; } - ReleaseTypePrimary convertReleaseTypePrimary(MetaData::Release::PrimaryType type) + ReleaseType::pointer getOrCreateReleaseType(Session& session, std::string_view name) { - switch (type) - { - case MetaData::Release::PrimaryType::Album: return ReleaseTypePrimary::Album; - case MetaData::Release::PrimaryType::Single: return ReleaseTypePrimary::Single; - case MetaData::Release::PrimaryType::EP: return ReleaseTypePrimary::EP; - case MetaData::Release::PrimaryType::Broadcast: return ReleaseTypePrimary::Broadcast; - case MetaData::Release::PrimaryType::Other: return ReleaseTypePrimary::Other; - } + ReleaseType::pointer releaseType{ ReleaseType::find(session, name) }; + if (!releaseType) + releaseType = session.create(name); - return ReleaseTypePrimary::Other; + return releaseType; } - EnumSet convertReleaseTypesSecondary(EnumSet types) - { - EnumSet res; - - for (MetaData::Release::SecondaryType type : types) - { - switch (type) - { - case MetaData::Release::SecondaryType::Compilation: - res.insert(ReleaseTypeSecondary::Compilation); - break; - case MetaData::Release::SecondaryType::Soundtrack: - res.insert(ReleaseTypeSecondary::Soundtrack); - break; - case MetaData::Release::SecondaryType::Spokenword: - res.insert(ReleaseTypeSecondary::Spokenword); - break; - case MetaData::Release::SecondaryType::Interview: - res.insert(ReleaseTypeSecondary::Interview); - break; - case MetaData::Release::SecondaryType::Audiobook: - res.insert(ReleaseTypeSecondary::Audiobook); - break; - case MetaData::Release::SecondaryType::AudioDrama: - res.insert(ReleaseTypeSecondary::AudioDrama); - break; - case MetaData::Release::SecondaryType::Live: - res.insert(ReleaseTypeSecondary::Live); - break; - case MetaData::Release::SecondaryType::Remix: - res.insert(ReleaseTypeSecondary::Remix); - break; - case MetaData::Release::SecondaryType::DJMix: - res.insert(ReleaseTypeSecondary::DJMix); - break; - case MetaData::Release::SecondaryType::Mixtape_Street: - res.insert(ReleaseTypeSecondary::Mixtape_Street); - break; - case MetaData::Release::SecondaryType::Demo: - res.insert(ReleaseTypeSecondary::Demo); - break; - } - } - - return res; - } - - void updateReleaseIfNeeded(Release::pointer release, const MetaData::Release& releaseInfo) + void updateReleaseIfNeeded(Session& session, Release::pointer release, const MetaData::Release& releaseInfo) { if (release->getName() != releaseInfo.name) release.modify()->setName(releaseInfo.name); if (release->getTotalDisc() != releaseInfo.mediumCount) release.modify()->setTotalDisc(releaseInfo.mediumCount); - if (releaseInfo.primaryType) - { - const ReleaseTypePrimary primaryType{ convertReleaseTypePrimary(*releaseInfo.primaryType) }; - if (release->getPrimaryType() != primaryType) - release.modify()->setPrimaryType(primaryType); - } - const EnumSet secondaryTypes{ convertReleaseTypesSecondary(releaseInfo.secondaryTypes) }; - if (release->getSecondaryTypes() != secondaryTypes) - release.modify()->setSecondaryTypes(secondaryTypes); if (release->getArtistDisplayName() != releaseInfo.artistDisplayName) release.modify()->setArtistDisplayName(releaseInfo.artistDisplayName); + if (release->getReleaseTypeNames() != releaseInfo.releaseTypes) + { + release.modify()->clearReleaseTypes(); + for (std::string_view releaseType : releaseInfo.releaseTypes) + release.modify()->addReleaseType(getOrCreateReleaseType(session, releaseType)); + } } Release::pointer getOrCreateRelease(Session& session, const MetaData::Release& releaseInfo, const std::filesystem::path& expectedReleaseDirectory) @@ -205,7 +150,7 @@ namespace Scanner if (!release) release = session.create(releaseInfo.name, releaseInfo.mbid); - updateReleaseIfNeeded(release, releaseInfo); + updateReleaseIfNeeded(session, release, releaseInfo); return release; } @@ -226,7 +171,7 @@ namespace Scanner if (!release) release = session.create(releaseInfo.name); - updateReleaseIfNeeded(release, releaseInfo); + updateReleaseIfNeeded(session, release, releaseInfo); return release; } @@ -279,10 +224,7 @@ namespace Scanner void ScanStepScanFiles::process(ScanContext& context) { - std::vector tagsToParse{ _tagsToParse }; - tagsToParse.insert(std::end(tagsToParse), std::cbegin(_settings.extraTags), std::cend(_settings.extraTags)); - - _metadataParser->setExtraTags(tagsToParse); + _metadataParser->setUserExtraTags(_extraTagsToParse); context.currentStepStats.totalElems = context.stats.filesScanned; @@ -488,7 +430,7 @@ namespace Scanner track.modify()->setTotalTrack(trackInfo->medium ? trackInfo->medium->trackCount : std::nullopt); track.modify()->setReleaseReplayGain(trackInfo->medium ? trackInfo->medium->replayGain : std::nullopt); track.modify()->setDiscSubtitle(trackInfo->medium ? trackInfo->medium->name : ""); - track.modify()->setClusters(getOrCreateClusters(dbSession, trackInfo->tags)); + track.modify()->setClusters(getOrCreateClusters(dbSession, trackInfo->userExtraTags)); track.modify()->setLastWriteTime(lastWriteTime); track.modify()->setName(title); track.modify()->setDuration(trackInfo->duration); diff --git a/src/libs/services/scanner/impl/ScanStepScanFiles.hpp b/src/libs/services/scanner/impl/ScanStepScanFiles.hpp index 298ca9bb..aeeb0775 100644 --- a/src/libs/services/scanner/impl/ScanStepScanFiles.hpp +++ b/src/libs/services/scanner/impl/ScanStepScanFiles.hpp @@ -41,6 +41,6 @@ namespace Scanner void scanAudioFile(const std::filesystem::path& file, ScanContext& context); std::unique_ptr _metadataParser; - const std::vector _tagsToParse{ "GENRE", "MOOD", "LANGUAGE", "ALBUMGROUPING" }; + const std::vector _extraTagsToParse{ "GENRE", "MOOD", "LANGUAGE", "ALBUMGROUPING" }; }; } diff --git a/src/libs/services/scrobbling/impl/ScrobblingService.cpp b/src/libs/services/scrobbling/impl/ScrobblingService.cpp index 2770b045..eb5c52eb 100644 --- a/src/libs/services/scrobbling/impl/ScrobblingService.cpp +++ b/src/libs/services/scrobbling/impl/ScrobblingService.cpp @@ -214,5 +214,20 @@ namespace Scrobbling res = Database::Listen::getTopTracks(session, userId, *backend, clusterIds, range); return res; } + + ScrobblingService::TrackContainer ScrobblingService::getTopTracks(UserId userId, Database::ArtistId artistId, const std::vector& clusterIds, Range range) + { + TrackContainer res; + + const auto backend{ getUserBackend(userId) }; + if (!backend) + return res; + + Session& session{ _db.getTLSSession() }; + auto transaction{ session.createReadTransaction() }; + + res = Database::Listen::getTopTracks(session, userId, artistId, *backend, clusterIds, range); + return res; + } } // ns Scrobbling diff --git a/src/libs/services/scrobbling/impl/ScrobblingService.hpp b/src/libs/services/scrobbling/impl/ScrobblingService.hpp index 667897f7..c6f08508 100644 --- a/src/libs/services/scrobbling/impl/ScrobblingService.hpp +++ b/src/libs/services/scrobbling/impl/ScrobblingService.hpp @@ -52,6 +52,7 @@ namespace Scrobbling ArtistContainer getTopArtists(Database::UserId userId, const std::vector& clusterIds, std::optional linkType, Database::Range range) override; ReleaseContainer getTopReleases(Database::UserId userId, const std::vector& clusterIds, Database::Range range) override; TrackContainer getTopTracks(Database::UserId userId, const std::vector& clusterIds, Database::Range range) override; + TrackContainer getTopTracks(Database::UserId userId, Database::ArtistId artistId, const std::vector& clusterIds, Database::Range range) override; std::optional getUserBackend(Database::UserId userId); diff --git a/src/libs/services/scrobbling/include/services/scrobbling/IScrobblingService.hpp b/src/libs/services/scrobbling/include/services/scrobbling/IScrobblingService.hpp index 892d9ee8..35ba2459 100644 --- a/src/libs/services/scrobbling/include/services/scrobbling/IScrobblingService.hpp +++ b/src/libs/services/scrobbling/include/services/scrobbling/IScrobblingService.hpp @@ -71,6 +71,7 @@ namespace Scrobbling virtual ArtistContainer getTopArtists(Database::UserId userId, const std::vector& clusterIds, std::optional linkType, Database::Range) = 0; virtual ReleaseContainer getTopReleases(Database::UserId userId, const std::vector& clusterIds, Database::Range range) = 0; virtual TrackContainer getTopTracks(Database::UserId userId, const std::vector& clusterIds, Database::Range range) = 0; + virtual TrackContainer getTopTracks(Database::UserId userId, Database::ArtistId artistId, const std::vector& clusterIds, Database::Range range) = 0; }; std::unique_ptr createScrobblingService(boost::asio::io_service& ioService, Database::Db& db); diff --git a/src/libs/subsonic/impl/ProtocolVersion.hpp b/src/libs/subsonic/impl/ProtocolVersion.hpp index 6dd17d54..ba2c5788 100644 --- a/src/libs/subsonic/impl/ProtocolVersion.hpp +++ b/src/libs/subsonic/impl/ProtocolVersion.hpp @@ -31,7 +31,7 @@ namespace API::Subsonic }; static inline constexpr ProtocolVersion defaultServerProtocolVersion{ 1, 16, 0 }; - static inline constexpr std::string_view serverVersion{ "4" }; + static inline constexpr std::string_view serverVersion{ "5" }; } namespace StringUtils diff --git a/src/libs/subsonic/impl/SubsonicResource.cpp b/src/libs/subsonic/impl/SubsonicResource.cpp index b472bf78..92797b30 100644 --- a/src/libs/subsonic/impl/SubsonicResource.cpp +++ b/src/libs/subsonic/impl/SubsonicResource.cpp @@ -182,7 +182,7 @@ namespace API::Subsonic {"/getAlbumInfo2", {handleNotImplemented}}, {"/getSimilarSongs", {handleGetSimilarSongsRequest}}, {"/getSimilarSongs2", {handleGetSimilarSongs2Request}}, - {"/getTopSongs", {handleNotImplemented}}, + {"/getTopSongs", {handleGetTopSongs}}, // Album/song lists {"/getAlbumList", {handleGetAlbumListRequest}}, diff --git a/src/libs/subsonic/impl/entrypoints/Browsing.cpp b/src/libs/subsonic/impl/entrypoints/Browsing.cpp index 45765597..b6cbe1a4 100644 --- a/src/libs/subsonic/impl/entrypoints/Browsing.cpp +++ b/src/libs/subsonic/impl/entrypoints/Browsing.cpp @@ -26,6 +26,7 @@ #include "database/Track.hpp" #include "database/User.hpp" #include "services/recommendation/IRecommendationService.hpp" +#include "services/scrobbling/IScrobblingService.hpp" #include "utils/ILogger.hpp" #include "utils/Random.hpp" #include "utils/Service.hpp" @@ -480,4 +481,34 @@ namespace API::Subsonic return handleGetSimilarSongsRequestCommon(context, true /* id3 */); } + Response handleGetTopSongs(RequestContext& context) + { + // Mandatory params + std::string_view artistName{ getMandatoryParameterAs(context.parameters, "artist") }; + std::size_t count{ getParameterAs(context.parameters, "count").value_or(50) }; + if (count > defaultMaxCountSize) + throw ParameterValueTooHighGenericError{ "count", defaultMaxCountSize }; + + auto transaction{ context.dbSession.createReadTransaction() }; + + const auto artists{ Artist::find(context.dbSession, artistName) }; + if (artists.size() != 1) + throw RequestedDataNotFoundError{}; + + User::pointer user{ User::find(context.dbSession, context.userId) }; + if (!user) + throw UserNotAuthorizedError{}; + + Response response{ Response::createOkResponse(context.serverProtocolVersion) }; + Response::Node& topSongs{ response.createNode("topSongs") }; + + const auto trackIds{ Service::get()->getTopTracks(context.userId, artists.front()->getId(), {}, Database::Range{ 0, count }) }; + for (const TrackId trackId : trackIds.results) + { + if (Track::pointer track{ Track::find(context.dbSession, trackId) }) + topSongs.addArrayChild("song", createSongNode(context, track, user)); + } + + return response; + } } diff --git a/src/libs/subsonic/impl/entrypoints/Browsing.hpp b/src/libs/subsonic/impl/entrypoints/Browsing.hpp index 3253db39..d87c787e 100644 --- a/src/libs/subsonic/impl/entrypoints/Browsing.hpp +++ b/src/libs/subsonic/impl/entrypoints/Browsing.hpp @@ -36,4 +36,5 @@ namespace API::Subsonic Response handleGetArtistInfo2Request(RequestContext& context); Response handleGetSimilarSongsRequest(RequestContext& context); Response handleGetSimilarSongs2Request(RequestContext& context); + Response handleGetTopSongs(RequestContext& context); } diff --git a/src/libs/subsonic/impl/entrypoints/MediaRetrieval.cpp b/src/libs/subsonic/impl/entrypoints/MediaRetrieval.cpp index 464937a7..eed28f47 100644 --- a/src/libs/subsonic/impl/entrypoints/MediaRetrieval.cpp +++ b/src/libs/subsonic/impl/entrypoints/MediaRetrieval.cpp @@ -269,13 +269,9 @@ namespace API::Subsonic else if (releaseId) cover = Service::get()->getFromRelease(*releaseId, size); else if (artistId) - { - // TODO handle a placeholder for artists - response.setStatus(404); - return; - } + cover = Service::get()->getFromArtist(*artistId, size); - if (!cover && context.enableDefaultCover) + if (!cover && context.enableDefaultCover && !artistId) cover = Service::get()->getDefault(size); if (!cover) diff --git a/src/libs/subsonic/impl/entrypoints/Playlists.cpp b/src/libs/subsonic/impl/entrypoints/Playlists.cpp index 3b9373a7..75d1488e 100644 --- a/src/libs/subsonic/impl/entrypoints/Playlists.cpp +++ b/src/libs/subsonic/impl/entrypoints/Playlists.cpp @@ -89,7 +89,7 @@ namespace API::Subsonic std::vector trackIds{ getMultiParametersAs(context.parameters, "songId") }; if (!name && !id) - throw RequiredParameterMissingError{ "name or id" }; + throw RequiredParameterMissingError{ "name or playlistId" }; auto transaction{ context.dbSession.createWriteTransaction() }; @@ -125,7 +125,16 @@ namespace API::Subsonic context.dbSession.create(track, tracklist); } - return Response::createOkResponse(context.serverProtocolVersion); + Response response{ Response::createOkResponse(context.serverProtocolVersion) }; + Response::Node playlistNode{ createPlaylistNode(tracklist, context.dbSession) }; + + auto entries{ tracklist->getEntries() }; + for (const TrackListEntry::pointer& entry : entries) + playlistNode.addArrayChild("entry", createSongNode(context, entry->getTrack(), user)); + + response.addNode("playlist", std::move(playlistNode)); + + return response; } Response handleUpdatePlaylistRequest(RequestContext& context) diff --git a/src/libs/subsonic/impl/responses/Album.cpp b/src/libs/subsonic/impl/responses/Album.cpp index b3917c39..412b5bd7 100644 --- a/src/libs/subsonic/impl/responses/Album.cpp +++ b/src/libs/subsonic/impl/responses/Album.cpp @@ -37,43 +37,6 @@ namespace API::Subsonic { using namespace Database; - namespace - { - std::string_view toString(ReleaseTypePrimary releaseType) - { - switch (releaseType) - { - case ReleaseTypePrimary::Album: return "album"; - case ReleaseTypePrimary::Broadcast: return "broadcast"; - case ReleaseTypePrimary::EP: return "ep"; - case ReleaseTypePrimary::Single: return "single"; - case ReleaseTypePrimary::Other: return "other"; - } - - return "unknown"; - } - - std::string_view toString(ReleaseTypeSecondary releaseType) - { - switch (releaseType) - { - case ReleaseTypeSecondary::Audiobook: return "audiobook"; - case ReleaseTypeSecondary::AudioDrama: return "audiodrama"; - case ReleaseTypeSecondary::Compilation: return "compilation"; - case ReleaseTypeSecondary::Demo: return "demo"; - case ReleaseTypeSecondary::DJMix: return "djmix"; - case ReleaseTypeSecondary::Interview: return "interview"; - case ReleaseTypeSecondary::Live: return "live"; - case ReleaseTypeSecondary::Mixtape_Street: return "mixtapestreet"; - case ReleaseTypeSecondary::Remix: return "remix"; - case ReleaseTypeSecondary::Soundtrack: return "soundtrack"; - case ReleaseTypeSecondary::Spokenword: return "soundtrack"; - } - - return "unknown"; - } - } - Response::Node createAlbumNode(RequestContext& context, const Release::pointer& release, const User::pointer& user, bool id3) { Response::Node albumNode; @@ -192,12 +155,20 @@ namespace API::Subsonic albumNode.setAttribute("originalReleaseDate", originalReleaseDate.isValid() ? StringUtils::toISO8601String(originalReleaseDate) : ""); } - albumNode.setAttribute("isCompilation", release->getSecondaryTypes().contains(ReleaseTypeSecondary::Compilation)); - albumNode.createEmptyArrayValue("releaseTypes"); - if (auto releaseType{ release->getPrimaryType() }) - albumNode.addArrayValue("releaseTypes", toString(*releaseType)); - for (const ReleaseTypeSecondary releaseType : release->getSecondaryTypes()) - albumNode.addArrayValue("releaseTypes", toString(releaseType)); + { + bool isCompilation{}; + albumNode.createEmptyArrayValue("releaseTypes"); + for (std::string_view releaseType : release->getReleaseTypeNames()) + { + if (StringUtils::stringCaseInsensitiveEqual(releaseType, "compilation")) + isCompilation = true; + + albumNode.addArrayValue("releaseTypes", releaseType); + } + + // TODO: the Compilation tag does not have the same meaning + albumNode.setAttribute("isCompilation", isCompilation); + } // disc titles albumNode.createEmptyArrayChild("discTitles"); diff --git a/src/libs/subsonic/impl/responses/Artist.cpp b/src/libs/subsonic/impl/responses/Artist.cpp index bdd0d374..0dddd170 100644 --- a/src/libs/subsonic/impl/responses/Artist.cpp +++ b/src/libs/subsonic/impl/responses/Artist.cpp @@ -79,6 +79,7 @@ namespace API::Subsonic artistNode.setAttribute("id", idToString(artist->getId())); artistNode.setAttribute("name", artist->getName()); + artistNode.setAttribute("coverArt", idToString(artist->getId())); if (id3) { diff --git a/src/libs/subsonic/impl/responses/Playlist.cpp b/src/libs/subsonic/impl/responses/Playlist.cpp index a929d770..db8cd626 100644 --- a/src/libs/subsonic/impl/responses/Playlist.cpp +++ b/src/libs/subsonic/impl/responses/Playlist.cpp @@ -19,6 +19,7 @@ #include "Playlist.hpp" +#include "database/Track.hpp" #include "database/TrackList.hpp" #include "database/User.hpp" #include "SubsonicId.hpp" @@ -41,6 +42,9 @@ namespace API::Subsonic playlistNode.setAttribute("created", reportedDummyDate); playlistNode.setAttribute("owner", tracklist->getUser()->getLoginName()); + if (const auto entry {tracklist->getEntry(0)}) + playlistNode.setAttribute("coverArt", idToString(entry->getTrack()->getId())); + return playlistNode; } } \ No newline at end of file diff --git a/src/libs/utils/impl/Path.cpp b/src/libs/utils/impl/Path.cpp index b42de130..c42d7a23 100644 --- a/src/libs/utils/impl/Path.cpp +++ b/src/libs/utils/impl/Path.cpp @@ -162,4 +162,21 @@ namespace PathUtils return false; } + + std::filesystem::path getLongestCommonPath(const std::filesystem::path& path1, const std::filesystem::path& path2) + { + std::filesystem::path longestCommonPath; + + auto it1{ path1.begin() }; + auto it2{ path2.begin() }; + + while (it1 != std::cend(path1) && it2 != std::cend(path2) && *it1 == *it2) + { + longestCommonPath /= *it1; + ++it1; + ++it2; + } + + return longestCommonPath; + } } // ns PathUtils diff --git a/src/libs/utils/include/utils/Path.hpp b/src/libs/utils/include/utils/Path.hpp index 52f62136..72f81993 100644 --- a/src/libs/utils/include/utils/Path.hpp +++ b/src/libs/utils/include/utils/Path.hpp @@ -28,23 +28,39 @@ namespace PathUtils { - std::uint32_t computeCrc32(const std::filesystem::path& p); + std::uint32_t computeCrc32(const std::filesystem::path& p); - // Make sure the given path is a directory - // Create it if needed - bool ensureDirectory(const std::filesystem::path& dir); + // 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); + // Get the last write time since Epoch + Wt::WDateTime getLastWriteTime(const std::filesystem::path& dir); - // returns false if aborted by user - bool exploreFilesRecursive(const std::filesystem::path& directory, std::function cb, const std::filesystem::path* excludeDirFileName = {}); + // returns false if aborted by user + bool exploreFilesRecursive(const std::filesystem::path& directory, std::function cb, const std::filesystem::path* excludeDirFileName = {}); - // Check if file's extension is one of provided extensions - bool hasFileAnyExtension(const std::filesystem::path& file, const std::vector& extensions); + // Check if file's extension is one of provided extensions + bool hasFileAnyExtension(const std::filesystem::path& file, const std::vector& extensions); - // Check if a path is within a directory (excludeDirFileName is a relative can be used to exclude a whole directory and its subdirectory, must not have parent_path) - bool isPathInRootPath(const std::filesystem::path& path, const std::filesystem::path& rootPath, const std::filesystem::path* excludeDirFileName = {}); + // Check if a path is within a directory (excludeDirFileName is a relative can be used to exclude a whole directory and its subdirectory, must not have parent_path) + bool isPathInRootPath(const std::filesystem::path& path, const std::filesystem::path& rootPath, const std::filesystem::path* excludeDirFileName = {}); + std::filesystem::path getLongestCommonPath(const std::filesystem::path& path1, const std::filesystem::path& path2); + template + std::filesystem::path getLongestCommonPath(Iterator first, Iterator last) + { + std::filesystem::path longestCommonPath; + + if (first == last) + return longestCommonPath; + + longestCommonPath = *first++; + + while (first != last) + longestCommonPath = PathUtils::getLongestCommonPath(*first++, longestCommonPath); + + return longestCommonPath; + } } diff --git a/src/libs/utils/test/CMakeLists.txt b/src/libs/utils/test/CMakeLists.txt index 48da8343..fbfb94e7 100644 --- a/src/libs/utils/test/CMakeLists.txt +++ b/src/libs/utils/test/CMakeLists.txt @@ -2,6 +2,7 @@ include(GoogleTest) add_executable(test-utils EnumSet.cpp + Path.cpp RecursiveSharedMutex.cpp String.cpp Utils.cpp diff --git a/src/libs/utils/test/Path.cpp b/src/libs/utils/test/Path.cpp new file mode 100644 index 00000000..f36ffa4b --- /dev/null +++ b/src/libs/utils/test/Path.cpp @@ -0,0 +1,78 @@ +/* + * 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 . + */ + +#include + +#include "utils/Path.hpp" + +TEST(Path, getLongestCommonPath) +{ + using namespace PathUtils; + + struct TestCase + { + std::filesystem::path path1; + std::filesystem::path path2; + std::filesystem::path expectedCommonPath; + }; + + TestCase tests[] + { + {"foo.txt", "/foo/foo.txt", ""}, + {"/", "/file.txt", "/"}, + {"/foo/bar/file1.txt", "/foo/bar/file2.txt", "/foo/bar"}, + {"/foo/bar/file.txt", "/foo/bar/file.txt", "/foo/bar/file.txt"}, + {"/dir1/file.txt", "/dir2/file.txt", "/"}, + {"/prefix/folder/file.txt", "/prefix/folder/subfolder/file.txt", "/prefix/folder"}, + }; + + for (const TestCase& test : tests) + { + EXPECT_EQ(PathUtils::getLongestCommonPath(test.path1, test.path2), test.expectedCommonPath); + } +} + + +TEST(Path, getLongestCommonPathIterator) +{ + using namespace PathUtils; + + struct TestCase + { + std::vector paths; + std::filesystem::path expectedCommonPath; + }; + + TestCase tests[] + { + {{}, ""}, + {{"/"}, "/"}, + {{"/foo", "/bar"}, "/"}, + {{"/foo/bar/file1.txt", "/foo/bar/file2.txt"}, "/foo/bar"}, + {{"/foo", "/foo/"}, "/foo"}, + {{"/foo/", "/foo/"}, "/foo/"}, + {{"/foo/", "/foo/", "/bar"}, "/"}, + {{"/foo/", "/foo/", "/foo/bar"}, "/foo"}, + }; + + for (const TestCase& test : tests) + { + EXPECT_EQ(PathUtils::getLongestCommonPath(std::cbegin(test.paths), std::cend(test.paths)), test.expectedCommonPath); + } +} \ No newline at end of file diff --git a/src/lms/CMakeLists.txt b/src/lms/CMakeLists.txt index d1d5db58..87adf57a 100644 --- a/src/lms/CMakeLists.txt +++ b/src/lms/CMakeLists.txt @@ -38,6 +38,7 @@ add_executable(lms ui/explore/ReleaseHelpers.cpp ui/explore/ReleasesView.cpp ui/explore/ReleaseView.cpp + ui/explore/ReleaseTypes.cpp ui/explore/SearchView.cpp ui/explore/TrackCollector.cpp ui/explore/TrackListHelpers.cpp @@ -70,4 +71,3 @@ target_link_libraries(lms PRIVATE ) install(TARGETS lms DESTINATION bin) - diff --git a/src/lms/main.cpp b/src/lms/main.cpp index 696bdb94..174c68af 100644 --- a/src/lms/main.cpp +++ b/src/lms/main.cpp @@ -292,7 +292,7 @@ int main(int argc, char* argv[]) scannerService->getEvents().scanComplete.connect([&] { // Flush cover cache even if no changes: - // covers may be external files that changed and we don't keep track of them + // covers may be external files that changed and we don't keep track of them for now (but we should) coverService->flushCache(); }); diff --git a/src/lms/ui/explore/ArtistView.cpp b/src/lms/ui/explore/ArtistView.cpp index 08cd7343..736d5c6d 100644 --- a/src/lms/ui/explore/ArtistView.cpp +++ b/src/lms/ui/explore/ArtistView.cpp @@ -69,18 +69,6 @@ namespace UserInterface } } - bool Artist::ReleaseType::operator<(const ReleaseType& other) const - { - if (!primaryType && other.primaryType) - return false; - else if (primaryType && !other.primaryType) - return true; - else if (*primaryType == *other.primaryType) - return secondaryTypes.getBitfield() < other.secondaryTypes.getBitfield(); - else - return static_cast(*primaryType) < static_cast(*other.primaryType); - } - Artist::Artist(Filters& filters, PlayQueueController& controller) : Template{ Wt::WString::tr("Lms.Explore.Artist.template") } , _filters{ filters } @@ -217,12 +205,12 @@ namespace UserInterface const auto releases{ Release::findIds(LmsApp->getDbSession(), params) }; if (!releases.results.empty()) { - // first pass: gather all ids and sort by type + // first pass: gather all ids and sort by release type for (const ReleaseId releaseId : releases.results) { const Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), releaseId) }; - ReleaseType releaseType{ release->getPrimaryType(), release->getSecondaryTypes() }; + ReleaseType releaseType{ parseReleaseType(release->getReleaseTypeNames())}; _releaseContainers[releaseType].releases.push_back(releaseId); } @@ -232,11 +220,11 @@ namespace UserInterface { Wt::WTemplate* releaseContainer{ releaseContainers->addNew(Wt::WString::tr("Lms.Explore.Artist.template.release-container")) }; - if (releaseType.primaryType) - releaseContainer->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(*releaseType.primaryType, releaseType.secondaryTypes)); + if (releaseType.primaryType || !releaseType.customTypes.empty()) + releaseContainer->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(releaseType)); else - releaseContainer->bindString("release-type", Wt::WString::tr("Lms.Explore.releases")); // fallback when not tagged with MB - + releaseContainer->bindString("release-type", Wt::WString::tr("Lms.Explore.releases")); // fallback when not tagged with MB or custom type + releases.container = releaseContainer->bindNew("releases", Wt::WString::tr("Lms.Explore.Releases.template.container")); releases.container->onRequestElements.connect(this, [this, &releases = releases] { diff --git a/src/lms/ui/explore/ArtistView.hpp b/src/lms/ui/explore/ArtistView.hpp index 7855ea86..c5d732a3 100644 --- a/src/lms/ui/explore/ArtistView.hpp +++ b/src/lms/ui/explore/ArtistView.hpp @@ -24,63 +24,56 @@ #include "database/ArtistId.hpp" #include "database/Object.hpp" #include "database/ReleaseId.hpp" -#include "database/Types.hpp" #include "utils/EnumSet.hpp" #include "common/Template.hpp" +#include "ReleaseTypes.hpp" namespace Database { - class Artist; - class Release; + class Artist; + class Release; } namespace UserInterface { - class Filters; - class PlayQueueController; - class InfiniteScrollingContainer; + class Filters; + class PlayQueueController; + class InfiniteScrollingContainer; - class Artist : public Template - { - public: - Artist(Filters& filters, PlayQueueController& controller); + class Artist : public Template + { + public: + Artist(Filters& filters, PlayQueueController& controller); - private: - void refreshView(); - void refreshReleases(); - void refreshAppearsOnReleases(); - void refreshNonReleaseTracks(); - void refreshSimilarArtists(const std::vector& similarArtistsId); - void refreshLinks(const Database::ObjectPtr& artist); + private: + void refreshView(); + void refreshReleases(); + void refreshAppearsOnReleases(); + void refreshNonReleaseTracks(); + void refreshSimilarArtists(const std::vector& similarArtistsId); + void refreshLinks(const Database::ObjectPtr& artist); - struct ReleaseContainer; - void addSomeReleases(ReleaseContainer& releaseContainer); - bool addSomeNonReleaseTracks(); - static constexpr std::size_t _releasesBatchSize {6}; - static constexpr std::size_t _tracksBatchSize {6}; - static constexpr std::size_t _tracksMaxCount {160}; + struct ReleaseContainer; + void addSomeReleases(ReleaseContainer& releaseContainer); + bool addSomeNonReleaseTracks(); + static constexpr std::size_t _releasesBatchSize{ 6 }; + static constexpr std::size_t _tracksBatchSize{ 6 }; + static constexpr std::size_t _tracksMaxCount{ 160 }; - Filters& _filters; - PlayQueueController& _playQueueController; + Filters& _filters; + PlayQueueController& _playQueueController; - struct ReleaseType - { - std::optional primaryType; - EnumSet secondaryTypes; - - bool operator<(const ReleaseType& other) const; - }; - - struct ReleaseContainer - { - InfiniteScrollingContainer* container {}; - std::vector releases; - }; - std::map _releaseContainers; - ReleaseContainer _appearsOnReleaseContainer {}; - InfiniteScrollingContainer* _trackContainer {}; - Database::ArtistId _artistId {}; - bool _needForceRefresh {}; - }; + // Display releases the same way as MusicBrainz + struct ReleaseContainer + { + InfiniteScrollingContainer* container{}; + std::vector releases; + }; + std::map _releaseContainers; + ReleaseContainer _appearsOnReleaseContainer{}; + InfiniteScrollingContainer* _trackContainer{}; + Database::ArtistId _artistId{}; + bool _needForceRefresh{}; + }; } // namespace UserInterface diff --git a/src/lms/ui/explore/ReleaseHelpers.cpp b/src/lms/ui/explore/ReleaseHelpers.cpp index e1e4a24d..2663ecf4 100644 --- a/src/lms/ui/explore/ReleaseHelpers.cpp +++ b/src/lms/ui/explore/ReleaseHelpers.cpp @@ -87,39 +87,52 @@ namespace UserInterface::ReleaseListHelpers namespace UserInterface::ReleaseHelpers { - Wt::WString buildReleaseTypeString(ReleaseTypePrimary primaryType, EnumSet secondaryTypes) + Wt::WString buildReleaseTypeString(const ReleaseType& releaseType) { Wt::WString res; - switch (primaryType) + if (releaseType.primaryType) { - case ReleaseTypePrimary::Album: res = Wt::WString::tr("Lms.Explore.Release.type-primary-album"); break; - case ReleaseTypePrimary::Broadcast: res = Wt::WString::tr("Lms.Explore.Release.type-primary-broadcast"); break; - case ReleaseTypePrimary::EP: res = Wt::WString::tr("Lms.Explore.Release.type-primary-ep"); break; - case ReleaseTypePrimary::Single: res = Wt::WString::tr("Lms.Explore.Release.type-primary-single"); break; - case ReleaseTypePrimary::Other: res = Wt::WString::tr("Lms.Explore.Release.type-primary-other"); break; + switch (*releaseType.primaryType) + { + case PrimaryReleaseType::Album: res = Wt::WString::tr("Lms.Explore.Release.type-primary-album"); break; + case PrimaryReleaseType::Broadcast: res = Wt::WString::tr("Lms.Explore.Release.type-primary-broadcast"); break; + case PrimaryReleaseType::EP: res = Wt::WString::tr("Lms.Explore.Release.type-primary-ep"); break; + case PrimaryReleaseType::Single: res = Wt::WString::tr("Lms.Explore.Release.type-primary-single"); break; + case PrimaryReleaseType::Other: res = Wt::WString::tr("Lms.Explore.Release.type-primary-other"); break; + } } - for (ReleaseTypeSecondary secondaryType : secondaryTypes) + for (SecondaryReleaseType secondaryType : releaseType.secondaryTypes) { - res += Wt::WString{ " · " }; + if (!res.empty()) + res += Wt::WString{ " · " }; switch (secondaryType) { - case ReleaseTypeSecondary::Compilation: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-compilation"); break; - case ReleaseTypeSecondary::Spokenword: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-spokenword"); break; - case ReleaseTypeSecondary::Soundtrack: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-soundtrack"); break; - case ReleaseTypeSecondary::Interview: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-interview"); break; - case ReleaseTypeSecondary::Audiobook: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-audiobook"); break; - case ReleaseTypeSecondary::AudioDrama: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-audiodrama"); break; - case ReleaseTypeSecondary::Live: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-live"); break; - case ReleaseTypeSecondary::Remix: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-remix"); break; - case ReleaseTypeSecondary::DJMix: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-djmix"); break; - case ReleaseTypeSecondary::Mixtape_Street: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-mixtape-street"); break; - case ReleaseTypeSecondary::Demo: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-demo"); break; + case SecondaryReleaseType::Compilation: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-compilation"); break; + case SecondaryReleaseType::Spokenword: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-spokenword"); break; + case SecondaryReleaseType::Soundtrack: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-soundtrack"); break; + case SecondaryReleaseType::Interview: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-interview"); break; + case SecondaryReleaseType::Audiobook: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-audiobook"); break; + case SecondaryReleaseType::AudioDrama: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-audiodrama"); break; + case SecondaryReleaseType::Live: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-live"); break; + case SecondaryReleaseType::Remix: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-remix"); break; + case SecondaryReleaseType::DJMix: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-djmix"); break; + case SecondaryReleaseType::Mixtape_Street: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-mixtape-street"); break; + case SecondaryReleaseType::Demo: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-demo"); break; + case SecondaryReleaseType::FieldRecording: res += Wt::WString::tr("Lms.Explore.Release.type-secondary-field-recording"); break; } } + for (const std::string& customType : releaseType.customTypes) + { + if (!res.empty()) + res += Wt::WString{ " · " }; + + res += customType; + } + return res; } diff --git a/src/lms/ui/explore/ReleaseHelpers.hpp b/src/lms/ui/explore/ReleaseHelpers.hpp index e91e6dcc..aab70f29 100644 --- a/src/lms/ui/explore/ReleaseHelpers.hpp +++ b/src/lms/ui/explore/ReleaseHelpers.hpp @@ -28,6 +28,7 @@ #include "database/Object.hpp" #include "database/Types.hpp" #include "utils/EnumSet.hpp" +#include "ReleaseTypes.hpp" namespace Database { @@ -43,6 +44,6 @@ namespace UserInterface::ReleaseListHelpers namespace UserInterface::ReleaseHelpers { - Wt::WString buildReleaseTypeString(Database::ReleaseTypePrimary primaryType, EnumSet secondaryTypes); + Wt::WString buildReleaseTypeString(const ReleaseType& releaseType); Wt::WString buildReleaseYearString(const Wt::WDate& releaseDate, const Wt::WDate& originalReleaseDate); } diff --git a/src/lms/ui/explore/ReleaseTypes.cpp b/src/lms/ui/explore/ReleaseTypes.cpp new file mode 100644 index 00000000..30356da7 --- /dev/null +++ b/src/lms/ui/explore/ReleaseTypes.cpp @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2023 Emeric Poupon + * + * This file is part of LMS. + * + * LMS is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * LMS is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with LMS. If not, see . + */ + +#include +#include + +#include "ReleaseTypes.hpp" +#include "utils/String.hpp" + +namespace StringUtils +{ + template<> + std::optional readAs(std::string_view str) + { + static const std::unordered_map entries + { + {"album", UserInterface::PrimaryReleaseType::Album}, + {"single", UserInterface::PrimaryReleaseType::Single}, + {"ep", UserInterface::PrimaryReleaseType::EP}, + {"broadcast", UserInterface::PrimaryReleaseType::Broadcast}, + {"other", UserInterface::PrimaryReleaseType::Other}, + }; + + const auto it{ entries.find(stringToLower(stringTrim(str))) }; + if (it == std::cend(entries)) + return std::nullopt; + + return it->second; + } + + template<> + std::optional readAs(std::string_view str) + { + static const std::unordered_map entries + { + {"compilation", UserInterface::SecondaryReleaseType::Compilation}, + {"soundtrack", UserInterface::SecondaryReleaseType::Soundtrack}, + {"spokenword", UserInterface::SecondaryReleaseType::Spokenword}, + {"interview", UserInterface::SecondaryReleaseType::Interview}, + {"audiobook", UserInterface::SecondaryReleaseType::Audiobook}, + {"audio drama", UserInterface::SecondaryReleaseType::AudioDrama}, + {"live", UserInterface::SecondaryReleaseType::Live}, + {"remix", UserInterface::SecondaryReleaseType::Remix}, + {"dj-mix", UserInterface::SecondaryReleaseType::DJMix}, + {"mixtape/street", UserInterface::SecondaryReleaseType::Mixtape_Street}, + {"demo", UserInterface::SecondaryReleaseType::Demo}, + {"field recording", UserInterface::SecondaryReleaseType::FieldRecording}, + }; + + const auto it{ entries.find(stringToLower(stringTrim(str))) }; + if (it == std::cend(entries)) + return std::nullopt; + + return it->second; + } +} + +namespace UserInterface +{ + ReleaseType parseReleaseType(const std::vector& releaseTypeNames) + { + ReleaseType res; + + for (std::string_view releaseTypeName : releaseTypeNames) + { + if (auto primaryType{ StringUtils::readAs(releaseTypeName) }) + { + if (!res.primaryType) + res.primaryType = primaryType; + else + res.customTypes.push_back(std::string{ releaseTypeName }); + } + else if (auto secondaryType{ StringUtils::readAs(releaseTypeName) }) + { + res.secondaryTypes.insert(*secondaryType); + } + else + res.customTypes.push_back(std::string{ releaseTypeName }); + } + + return res; + } + + bool operator<(std::optional typeA, std::optional typeB) + { + if (!typeA && typeB) + return false; + else if (typeA && !typeB) + return true; + else + return static_cast(*typeA) < static_cast(*typeB); + } + + bool operator<(EnumSet typesA, EnumSet typesB) + { + return typesA.getBitfield() < typesB.getBitfield(); + } + + bool ReleaseType::operator<(const ReleaseType& other) const + { + // TODO : order custom types and compare for each element (size is not to be compared first) + return std::tie(primaryType, secondaryTypes, customTypes) < std::tie(other.primaryType, other.secondaryTypes, other.customTypes); + } +} // namespace UserInterface diff --git a/src/lms/ui/explore/ReleaseTypes.hpp b/src/lms/ui/explore/ReleaseTypes.hpp new file mode 100644 index 00000000..00971048 --- /dev/null +++ b/src/lms/ui/explore/ReleaseTypes.hpp @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2023 Emeric Poupon + * + * This file is part of LMS. + * + * LMS is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * LMS is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with LMS. If not, see . + */ + +#pragma once + +#include +#include +#include +#include + +#include "utils/EnumSet.hpp" + +namespace UserInterface +{ + // see https://musicbrainz.org/doc/Release_Group/Type + enum class PrimaryReleaseType + { + Album, + Single, + EP, + Broadcast, + Other + }; + + enum class SecondaryReleaseType + { + Compilation, + Soundtrack, + Spokenword, + Interview, + Audiobook, + AudioDrama, + Live, + Remix, + DJMix, + Mixtape_Street, + Demo, + FieldRecording, + }; + + struct ReleaseType + { + std::optional primaryType; + EnumSet secondaryTypes; + std::vector customTypes; + + bool operator<(const ReleaseType& other) const; + }; + + ReleaseType parseReleaseType(const std::vector& releaseTypeNames); + +} // namespace UserInterface \ No newline at end of file diff --git a/src/lms/ui/explore/ReleaseView.cpp b/src/lms/ui/explore/ReleaseView.cpp index 93343cdd..c8f01c25 100644 --- a/src/lms/ui/explore/ReleaseView.cpp +++ b/src/lms/ui/explore/ReleaseView.cpp @@ -68,10 +68,10 @@ namespace UserInterface Wt::WWidget* releaseInfoPtr{ releaseInfo.get() }; releaseInfo->addFunction("tr", &Wt::WTemplate::Functions::tr); - if (auto primaryReleaseType{ release->getPrimaryType() }) + if (const auto releaseTypeNames{ release->getReleaseTypeNames() }; !releaseTypeNames.empty()) { releaseInfo->setCondition("if-has-release-type", true); - releaseInfo->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(*primaryReleaseType, release->getSecondaryTypes())); + releaseInfo->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(parseReleaseType(releaseTypeNames))); } std::map> artistMap; diff --git a/src/tools/metadata/LmsMetadata.cpp b/src/tools/metadata/LmsMetadata.cpp index 80d2d8e1..06139132 100644 --- a/src/tools/metadata/LmsMetadata.cpp +++ b/src/tools/metadata/LmsMetadata.cpp @@ -29,215 +29,169 @@ #include "metadata/IParser.hpp" #include "utils/StreamLogger.hpp" -static -std::ostream& -operator<<(std::ostream& os, const MetaData::Artist& artist) +namespace { - os << artist.name; - - if (artist.mbid) - os << " (" << artist.mbid->getAsString() << ")"; - - if (artist.sortName) - os << " '" << *artist.sortName << "'"; - - return os; -} - -static -std::ostream& -operator<<(std::ostream& os, MetaData::Release::PrimaryType type) -{ - switch (type) + std::ostream& operator<<(std::ostream& os, const MetaData::Artist& artist) { - case MetaData::Release::PrimaryType::Album: os << "Album"; break; - case MetaData::Release::PrimaryType::Single: os << "Single"; break; - case MetaData::Release::PrimaryType::EP: os << "EP"; break; - case MetaData::Release::PrimaryType::Broadcast: os << "Broadcast"; break; - case MetaData::Release::PrimaryType::Other: os << "Other"; break; - default: - os << "??"; - } - return os; -} + os << artist.name; -static -std::ostream& -operator<<(std::ostream& os, MetaData::Release::SecondaryType type) -{ - switch (type) - { - case MetaData::Release::SecondaryType::Compilation: os << "Compilation"; break; - case MetaData::Release::SecondaryType::Soundtrack: os << "Soundtrack"; break; - case MetaData::Release::SecondaryType::Spokenword: os << "Spokenword"; break; - case MetaData::Release::SecondaryType::Interview: os << "Interview"; break; - case MetaData::Release::SecondaryType::Audiobook: os << "Audiobook"; break; - case MetaData::Release::SecondaryType::AudioDrama: os << "Audio drama"; break; - case MetaData::Release::SecondaryType::Live: os << "Live"; break; - case MetaData::Release::SecondaryType::Remix: os << "Remix"; break; - case MetaData::Release::SecondaryType::DJMix: os << "DJ-mix"; break; - case MetaData::Release::SecondaryType::Mixtape_Street: os << "Mixtape/Street"; break; - case MetaData::Release::SecondaryType::Demo: os << "Mixtape/Demo"; break; - default: - os << "??"; - } - return os; -} + if (artist.mbid) + os << " (" << artist.mbid->getAsString() << ")"; -static -std::ostream& -operator<<(std::ostream& os, const MetaData::Release& release) -{ - os << release.name; + if (artist.sortName) + os << " '" << *artist.sortName << "'"; - if (release.mbid) - os << " (" << release.mbid->getAsString() << ")" << std::endl; - - if (release.mediumCount) - std::cout << "\tMediumCount: " << *release.mediumCount << std::endl; - - if (!release.artistDisplayName.empty()) - std::cout << "\tDisplay artist: " << release.artistDisplayName << std::endl; - - for (const MetaData::Artist& artist : release.artists) - std::cout << "\tRelease artist: " << artist << std::endl; - - if (release.primaryType) - { - std::cout << "\tPrimary type: " << *release.primaryType << std::endl; - for (MetaData::Release::SecondaryType type : release.secondaryTypes) - std::cout << "\tSecondary type:" << type << std::endl; + return os; } - return os; -} - -static -std::ostream& -operator<<(std::ostream& os, const MetaData::Medium& medium) -{ - if (!medium.name.empty()) - os << medium.name; - os << std::endl; - - if (medium.position) - os << "\tPosition: " << *medium.position << std::endl; - - if (!medium.type.empty()) - os << "\tType: " << medium.type << std::endl; - - if (medium.trackCount) - std::cout << "\tTrackCount: " << *medium.trackCount << std::endl; - - if (medium.replayGain) - std::cout << "\tReplay gain: " << *medium.replayGain << std::endl; - - if (medium.release) - std::cout << "Release: " << *medium.release << std::endl; - - return os; -} - -void parse(MetaData::IParser& parser, const std::filesystem::path& file) -{ - using namespace MetaData; - - parser.setExtraTags({ "MOOD", "ALBUMGROUPING", "GENRE", "LANGUAGE" }); - - const auto start{ std::chrono::steady_clock::now() }; - std::optional track{ parser.parse(file, true) }; - if (!track) + std::ostream& operator<<(std::ostream& os, const MetaData::Release& release) { - std::cerr << "Parsing failed" << std::endl; - return; - } - const auto end{ std::chrono::steady_clock::now() }; + os << release.name; - std::cout << "Parsing time: " << std::fixed << std::setprecision(2) << std::chrono::duration_cast(end - start).count() / 1000. << "ms" << std::endl; + if (release.mbid) + os << " (" << release.mbid->getAsString() << ")" << std::endl; - std::cout << "Parsed metadata:" << std::endl; + if (release.mediumCount) + std::cout << "\tMediumCount: " << *release.mediumCount << std::endl; - if (!track->artistDisplayName.empty()) - std::cout << "Display artist: " << track->artistDisplayName << std::endl; + if (!release.artistDisplayName.empty()) + std::cout << "\tDisplay artist: " << release.artistDisplayName << std::endl; - for (const Artist& artist : track->artists) - std::cout << "Artist: " << artist << std::endl; + for (const MetaData::Artist& artist : release.artists) + std::cout << "\tRelease artist: " << artist << std::endl; - for (const Artist& artist : track->conductorArtists) - std::cout << "Conductor: " << artist << std::endl; + std::cout << "Release types:" << std::endl; + for (std::string_view releaseType : release.releaseTypes) + std::cout << "\t" << releaseType << std::endl; - for (const Artist& artist : track->composerArtists) - std::cout << "Composer: " << artist << std::endl; - - for (const Artist& artist : track->lyricistArtists) - std::cout << "Lyricist: " << artist << std::endl; - - for (const Artist& artist : track->mixerArtists) - std::cout << "Mixer: " << artist << std::endl; - - for (const auto& [role, artists] : track->performerArtists) - { - std::cout << "Performer"; - if (!role.empty()) - std::cout << " (" << role << ")"; - std::cout << ":" << std::endl; - for (const Artist& artist : artists) - std::cout << "\t" << artist << std::endl; + return os; } - for (const Artist& artist : track->producerArtists) - std::cout << "Producer: " << artist << std::endl; - - for (const Artist& artist : track->remixerArtists) - std::cout << "Remixer: " << artist << std::endl; - - if (track->medium) - std::cout << "Medium: " << *track->medium; - - std::cout << "Title: " << track->title << std::endl; - - if (track->mbid) - std::cout << "Track MBID = " << track->mbid->getAsString() << std::endl; - - if (track->recordingMBID) - std::cout << "Recording MBID = " << track->recordingMBID->getAsString() << std::endl; - - for (const auto& [tag, values] : track->tags) + std::ostream& operator<<(std::ostream& os, const MetaData::Medium& medium) { - std::cout << "Tag: " << tag << std::endl; - for (const auto& value : values) + if (!medium.name.empty()) + os << medium.name; + os << std::endl; + + if (medium.position) + os << "\tPosition: " << *medium.position << std::endl; + + if (!medium.type.empty()) + os << "\tType: " << medium.type << std::endl; + + if (medium.trackCount) + std::cout << "\tTrackCount: " << *medium.trackCount << std::endl; + + if (medium.replayGain) + std::cout << "\tReplay gain: " << *medium.replayGain << std::endl; + + if (medium.release) + std::cout << "Release: " << *medium.release << std::endl; + + return os; + } + + void parse(MetaData::IParser& parser, const std::filesystem::path& file) + { + using namespace MetaData; + + parser.setUserExtraTags({ "MOOD", "ALBUMGROUPING", "GENRE", "LANGUAGE" }); + + const auto start{ std::chrono::steady_clock::now() }; + std::optional track{ parser.parse(file, true) }; + if (!track) { - std::cout << "\t" << value << std::endl; + std::cerr << "Parsing failed" << std::endl; + return; } + const auto end{ std::chrono::steady_clock::now() }; + + std::cout << "Parsing time: " << std::fixed << std::setprecision(2) << std::chrono::duration_cast(end - start).count() / 1000. << "ms" << std::endl; + + std::cout << "Parsed metadata:" << std::endl; + + if (!track->artistDisplayName.empty()) + std::cout << "Display artist: " << track->artistDisplayName << std::endl; + + for (const Artist& artist : track->artists) + std::cout << "Artist: " << artist << std::endl; + + for (const Artist& artist : track->conductorArtists) + std::cout << "Conductor: " << artist << std::endl; + + for (const Artist& artist : track->composerArtists) + std::cout << "Composer: " << artist << std::endl; + + for (const Artist& artist : track->lyricistArtists) + std::cout << "Lyricist: " << artist << std::endl; + + for (const Artist& artist : track->mixerArtists) + std::cout << "Mixer: " << artist << std::endl; + + for (const auto& [role, artists] : track->performerArtists) + { + std::cout << "Performer"; + if (!role.empty()) + std::cout << " (" << role << ")"; + std::cout << ":" << std::endl; + for (const Artist& artist : artists) + std::cout << "\t" << artist << std::endl; + } + + for (const Artist& artist : track->producerArtists) + std::cout << "Producer: " << artist << std::endl; + + for (const Artist& artist : track->remixerArtists) + std::cout << "Remixer: " << artist << std::endl; + + if (track->medium) + std::cout << "Medium: " << *track->medium; + + std::cout << "Title: " << track->title << std::endl; + + if (track->mbid) + std::cout << "Track MBID = " << track->mbid->getAsString() << std::endl; + + if (track->recordingMBID) + std::cout << "Recording MBID = " << track->recordingMBID->getAsString() << std::endl; + + for (const auto& [tag, values] : track->userExtraTags) + { + std::cout << "Tag: " << tag << std::endl; + for (const auto& value : values) + { + std::cout << "\t" << value << std::endl; + } + } + + std::cout << "Duration: " << std::fixed << std::setprecision(2) << track->duration.count() / 1000. << "s" << std::endl; + std::cout << "Bitrate: " << track->bitrate << " bps" << std::endl; + + if (track->position) + std::cout << "Position: " << *track->position << std::endl; + + if (track->date.isValid()) + std::cout << "Date: " << track->date.toString("yyyy-MM-dd") << std::endl; + + if (track->originalDate.isValid()) + std::cout << "Original date: " << track->originalDate.toString("yyyy-MM-dd") << std::endl; + + std::cout << "HasCover = " << std::boolalpha << track->hasCover << std::endl; + + if (track->replayGain) + std::cout << "Track replay gain: " << *track->replayGain << std::endl; + + if (track->acoustID) + std::cout << "AcoustID: " << track->acoustID->getAsString() << std::endl; + + if (!track->copyright.empty()) + std::cout << "Copyright: " << track->copyright << std::endl; + + if (!track->copyrightURL.empty()) + std::cout << "CopyrightURL: " << track->copyrightURL << std::endl; + + std::cout << std::endl; } - - std::cout << "Duration: " << std::fixed << std::setprecision(2) << track->duration.count() / 1000. << "s" << std::endl; - std::cout << "Bitrate: " << track->bitrate << " bps" << std::endl; - - if (track->position) - std::cout << "Position: " << *track->position << std::endl; - - if (track->date.isValid()) - std::cout << "Date: " << track->date.toString("yyyy-MM-dd") << std::endl; - - if (track->originalDate.isValid()) - std::cout << "Original date: " << track->originalDate.toString("yyyy-MM-dd") << std::endl; - - std::cout << "HasCover = " << std::boolalpha << track->hasCover << std::endl; - - if (track->replayGain) - std::cout << "Track replay gain: " << *track->replayGain << std::endl; - - if (track->acoustID) - std::cout << "AcoustID: " << track->acoustID->getAsString() << std::endl; - - if (!track->copyright.empty()) - std::cout << "Copyright: " << track->copyright << std::endl; - - if (!track->copyrightURL.empty()) - std::cout << "CopyrightURL: " << track->copyrightURL << std::endl; - - std::cout << std::endl; } int main(int argc, char* argv[])