owen/lms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Allowed custom release types + handle more MusicBrainz secondary types in UI. fixes #373

Browse Source
This commit is contained in:
emeric
2023-12-11 23:25:58 +01:00
parent a2cc243a08
commit 3ad990a183
33 changed files with 793 additions and 725 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/database/impl/IdTypeTraits.hpp
+25 -26
View File
@@ -26,35 +26,34 @@
namespace Wt::Dbo
{
template<typename T>
struct sql_value_traits<T, typename std::enable_if<std::is_base_of<Database::IdType, T>::value>::type>
{
static_assert(!std::is_same_v<Database::IdType, T>, "Cannot use IdType, use derived types");
static const bool specialized = true;
template<typename T>
struct sql_value_traits<T, typename std::enable_if<std::is_base_of<Database::IdType, T>::value>::type>
{
static_assert(!std::is_same_v<Database::IdType, T>, "Cannot use IdType, use derived types");
static const bool specialized = true;
static std::string type(SqlConnection* conn, int size)
{
return sql_value_traits<typename T::ValueType, void>::type(conn, size);
}
static std::string type(SqlConnection *conn, int size)
{
return sql_value_traits<typename T::ValueType, void>::type(conn, size);
}
static void bind(const T& v, SqlStatement* statement, int column, int size)
{
sql_value_traits<typename T::ValueType>::bind(v.getValue(), statement, column, size);
}
static void bind(const T& v, SqlStatement *statement, int column, int size)
{
sql_value_traits<typename T::ValueType>::bind(v.getValue(), statement, column, size);
}
static bool read(T& v, SqlStatement* statement, int column, int size)
{
typename T::ValueType value;
if (sql_value_traits<typename T::ValueType>::read(value, statement, column, size))
{
v = value;
return true;
}
static bool read(T& v, SqlStatement *statement, int column, int size)
{
typename T::ValueType value;
if (sql_value_traits<typename T::ValueType>::read(value, statement, column, size))
{
v = value;
return true;
}
v = {};
return false;
}
};
v = {};
return false;
}
};
}
src/libs/database/impl/Migration.cpp
+26
View File
@@ -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},
};
{
src/libs/database/impl/Migration.hpp
+1 -1
View File
@@ -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:
src/libs/database/impl/Release.cpp
+63 -5
View File
@@ -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<ReleaseType> {new ReleaseType{ name }});
}
ReleaseType::pointer ReleaseType::find(Session& session, ReleaseTypeId id)
{
session.checkReadTransaction();
return session.getDboSession()
.find<ReleaseType>()
.where("id = ?").bind(id)
.resultValue();
}
ReleaseType::pointer ReleaseType::find(Session& session, std::string_view name)
{
session.checkReadTransaction();
return session.getDboSession()
.find<ReleaseType>()
.where("name = ?").bind(name)
.resultValue();
}
Release::Release(const std::string& name, const std::optional<UUID>& MBID)
: _name{ std::string(name, 0 , _maxNameLength) },
_MBID{ MBID ? MBID->getAsString() : "" }
@@ -448,6 +481,16 @@ namespace Database
return std::vector<pointer>(res.begin(), res.end());
}
void Release::clearReleaseTypes()
{
_releaseTypes.clear();
}
void Release::addReleaseType(ObjectPtr<ReleaseType> releaseType)
{
_releaseTypes.insert(getDboPtr(releaseType));
}
bool Release::hasVariousArtists() const
{
// TODO optimize
@@ -459,6 +502,21 @@ namespace Database
return _tracks.size();
}
std::vector<ObjectPtr<ReleaseType>> Release::getReleaseTypes() const
{
return std::vector<ObjectPtr<ReleaseType>>(_releaseTypes.begin(), _releaseTypes.end());
}
std::vector<std::string> Release::getReleaseTypeNames() const
{
std::vector<std::string> res;
for (const auto& releaseType : _releaseTypes)
res.push_back(std::string{ releaseType->getName() });
return res;
}
std::chrono::milliseconds Release::getDuration() const
{
assert(session());
src/libs/database/impl/Session.cpp
+2
View File
@@ -82,6 +82,7 @@ namespace Database
_session.mapClass<ClusterType>("cluster_type");
_session.mapClass<Listen>("listen");
_session.mapClass<Release>("release");
_session.mapClass<ReleaseType>("release_type");
_session.mapClass<ScanSettings>("scan_settings");
_session.mapClass<StarredArtist>("starred_artist");
_session.mapClass<StarredRelease>("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)");
src/libs/database/impl/Track.cpp
+1 -2
View File
@@ -197,8 +197,7 @@ namespace Database
return session.getDboSession().add(std::unique_ptr<Track> {new Track{ p }});
}
std::size_t
Track::getCount(Session& session)
std::size_t Track::getCount(Session& session)
{
session.checkReadTransaction();
src/libs/database/include/database/Release.hpp
+41 -16
View File
@@ -21,6 +21,8 @@
#include <filesystem>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
#include <Wt/WDateTime.h>
@@ -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<ReleaseType, ReleaseTypeId>
{
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<class Action>
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<Wt::Dbo::ptr<Release>> _releases; // releases that match this type
};
class Release final : public Object<Release, ReleaseId>
{
public:
@@ -62,9 +92,8 @@ namespace Database
ArtistId artist; // only releases that involved this user
EnumSet<TrackArtistLinkType> trackArtistLinkTypes; // and for these link types
EnumSet<TrackArtistLinkType> excludedTrackArtistLinkTypes; // but not for these link types
std::optional<ReleaseTypePrimary> primaryType; // if set, matching this primary type
EnumSet<ReleaseTypeSecondary> secondaryTypes; // Matching all this (if any)
std::string releaseType; // If set, albums that has this release type
FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; }
FindParameters& setKeywords(const std::vector<std::string_view>& _keywords) { keywords = _keywords; return *this; }
FindParameters& 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<DiscInfo> getDiscs() const;
std::chrono::milliseconds getDuration() const;
Wt::WDateTime getLastWritten() const;
std::optional<ReleaseTypePrimary> getPrimaryType() const { return _primaryType; }
EnumSet<ReleaseTypeSecondary> getSecondaryTypes() const { return _secondaryTypes; }
std::string_view getArtistDisplayName() const { return _artistDisplayName; }
std::size_t getTracksCount() const;
std::vector<ObjectPtr<ReleaseType>> getReleaseTypes() const;
std::vector<std::string> getReleaseTypeNames() const;
// Setters
void setName(std::string_view name) { _name = name; }
void setMBID(const std::optional<UUID>& mbid) { _MBID = mbid ? mbid->getAsString() : ""; }
void setTotalDisc(std::optional<int> totalDisc) { _totalDisc = totalDisc; }
void setPrimaryType(std::optional<ReleaseTypePrimary> type) { _primaryType = type; }
void setSecondaryTypes(EnumSet<ReleaseTypeSecondary> types) { _secondaryTypes = types; }
void setArtistDisplayName(std::string_view name) { _artistDisplayName = name; }
void clearReleaseTypes();
void addReleaseType(ObjectPtr<ReleaseType> releaseType);
// Get the artists of this release
std::vector<ObjectPtr<Artist>> getArtists(TrackArtistLinkType type = TrackArtistLinkType::Artist) const;
@@ -135,17 +165,15 @@ namespace Database
bool hasVariousArtists() const;
std::vector<pointer> getSimilarReleases(std::optional<std::size_t> offset = {}, std::optional<std::size_t> count = {}) const;
template<class Action>
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<int> _totalDisc{};
std::optional<ReleaseTypePrimary> _primaryType;
EnumSet<ReleaseTypeSecondary> _secondaryTypes;
std::string _artistDisplayName;
Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _tracks; // Tracks in the release
Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _tracks; // Tracks in the release
Wt::Dbo::collection<Wt::Dbo::ptr<ReleaseType>> _releaseTypes; // Release types
};
} // namespace Database
src/libs/database/include/database/ReleaseTypeId.hpp
+25
View File
@@ -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 <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "database/IdType.hpp"
LMS_DECLARE_IDTYPE(ReleaseTypeId)
src/libs/database/include/database/Types.hpp
-25
View File
@@ -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,
};
}
src/libs/database/test/Common.hpp
+1 -1
View File
@@ -40,7 +40,7 @@
#include "database/User.hpp"
template <typename T>
class ScopedEntity
class [[nodiscard]] ScopedEntity
{
public:
using IdType = typename T::IdType;
src/libs/database/test/Release.cpp
+59 -6
View File
@@ -20,6 +20,7 @@
#include "Common.hpp"
using namespace Database;
using ScopedReleaseType = ScopedEntity<Database::ReleaseType>;
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<ReleaseTypeSecondary> {});
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());
}
}