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

SubsonicAPI: optimized search for tracks

Browse Source
This commit is contained in:
emeric
2023-11-04 17:36:59 +01:00
parent c4d2d20447
commit bd59dc3bc9
27 changed files with 3162 additions and 3301 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/services/cover/impl/CoverService.cpp
+104 -124
View File
@@ -34,33 +34,35 @@
#include "utils/String.hpp"
#include "utils/Utils.hpp"
namespace
namespace Cover
{
namespace
{
struct TrackInfo
{
bool hasCover {};
bool isMultiDisc {};
bool hasCover{};
bool isMultiDisc{};
std::filesystem::path trackPath;
std::optional<Database::ReleaseId> releaseId;
};
std::optional<TrackInfo>
getTrackInfo(Database::Session& dbSession, Database::TrackId trackId)
std::optional<TrackInfo> getTrackInfo(Database::Session& dbSession, Database::TrackId trackId)
{
std::optional<TrackInfo> res;
auto transaction {dbSession.createSharedTransaction()};
auto transaction{ dbSession.createSharedTransaction() };
const Database::Track::pointer track {Database::Track::find(dbSession, trackId)};
const Database::Track::pointer track{ Database::Track::find(dbSession, trackId) };
if (!track)
return res;
res = TrackInfo {};
res = TrackInfo{};
res->hasCover = track->hasCover();
res->trackPath = track->getPath();
if (const Database::Release::pointer& release {track->getRelease()})
if (const Database::Release::pointer & release{ track->getRelease() })
{
res->releaseId = release->getId();
if (release->getTotalDisc() > 1)
@@ -78,39 +80,34 @@ namespace
[&res](std::string_view fileName)
{
res.emplace_back(fileName);
}, {"cover", "front"});
}, { "cover", "front" });
return res;
}
}
namespace Cover {
using namespace Image;
static
bool
isFileSupported(const std::filesystem::path& file, const std::vector<std::filesystem::path>& extensions)
{
bool isFileSupported(const std::filesystem::path& file, const std::vector<std::filesystem::path>& extensions)
{
return (std::find(std::cbegin(extensions), std::cend(extensions), file.extension()) != std::cend(extensions));
}
}
}
std::unique_ptr<ICoverService>
createCoverService(Database::Db& db, const std::filesystem::path& execPath, const std::filesystem::path& defaultCoverPath)
{
std::unique_ptr<ICoverService> createCoverService(Database::Db& db, const std::filesystem::path& execPath, const std::filesystem::path& defaultCoverPath)
{
return std::make_unique<CoverService>(db, execPath, defaultCoverPath);
}
}
CoverService::CoverService(Database::Db& db,
using namespace Image;
CoverService::CoverService(Database::Db& db,
const std::filesystem::path& execPath,
const std::filesystem::path& defaultCoverPath)
: _db {db}
, _defaultCoverPath {defaultCoverPath}
, _maxCacheSize {Service<IConfig>::get()->getULong("cover-max-cache-size", 30) * 1000 * 1000}
, _maxFileSize {Service<IConfig>::get()->getULong("cover-max-file-size", 10) * 1000 * 1000}
, _preferredFileNames {constructPreferredFileNames()}
: _db{ db }
, _defaultCoverPath{ defaultCoverPath }
, _maxCacheSize{ Service<IConfig>::get()->getULong("cover-max-cache-size", 30) * 1000 * 1000 }
, _maxFileSize{ Service<IConfig>::get()->getULong("cover-max-file-size", 10) * 1000 * 1000 }
, _preferredFileNames{ constructPreferredFileNames() }
{
{
setJpegQuality(Service<IConfig>::get()->getULong("cover-jpeg-quality", 75));
LMS_LOG(COVER, INFO) << "Default cover path = '" << _defaultCoverPath.string() << "'";
@@ -132,11 +129,10 @@ CoverService::CoverService(Database::Db& db,
{
throw LmsException("Cannot read default cover file '" + _defaultCoverPath.string() + "': " + e.what());
}
}
}
std::unique_ptr<IEncodedImage>
CoverService::getFromAvMediaFile(const Av::IAudioFile& input, ImageSize width) const
{
std::unique_ptr<IEncodedImage> CoverService::getFromAvMediaFile(const Av::IAudioFile& input, ImageSize width) const
{
std::unique_ptr<IEncodedImage> image;
input.visitAttachedPictures([&](const Av::Picture& picture)
@@ -146,7 +142,7 @@ CoverService::getFromAvMediaFile(const Av::IAudioFile& input, ImageSize width) c
try
{
std::unique_ptr<IRawImage> rawImage {decodeImage(picture.data, picture.dataSize)};
std::unique_ptr<IRawImage> rawImage{ decodeImage(picture.data, picture.dataSize) };
rawImage->resize(width);
image = rawImage->encodeToJPEG(_jpegQuality);
}
@@ -157,16 +153,15 @@ CoverService::getFromAvMediaFile(const Av::IAudioFile& input, ImageSize width) c
});
return image;
}
}
std::unique_ptr<IEncodedImage>
CoverService::getFromCoverFile(const std::filesystem::path& p, ImageSize width) const
{
std::unique_ptr<IEncodedImage> CoverService::getFromCoverFile(const std::filesystem::path& p, ImageSize width) const
{
std::unique_ptr<IEncodedImage> image;
try
{
std::unique_ptr<IRawImage> rawImage {decodeImage(p)};
std::unique_ptr<IRawImage> rawImage{ decodeImage(p) };
rawImage->resize(width);
image = rawImage->encodeToJPEG(_jpegQuality);
}
@@ -176,43 +171,41 @@ CoverService::getFromCoverFile(const std::filesystem::path& p, ImageSize width)
}
return image;
}
}
std::shared_ptr<IEncodedImage>
CoverService::getDefault(ImageSize width)
{
std::shared_ptr<IEncodedImage> CoverService::getDefault(ImageSize width)
{
std::shared_lock lock {_cacheMutex};
{
std::shared_lock lock{ _cacheMutex };
if (auto it {_defaultCoverCache.find(width)}; it != std::cend(_defaultCoverCache))
if (auto it{ _defaultCoverCache.find(width) }; it != std::cend(_defaultCoverCache))
return it->second;
}
{
std::unique_lock lock {_cacheMutex};
std::unique_lock lock{ _cacheMutex };
if (auto it {_defaultCoverCache.find(width)}; it != std::cend(_defaultCoverCache))
if (auto it{ _defaultCoverCache.find(width) }; it != std::cend(_defaultCoverCache))
return it->second;
std::shared_ptr<IEncodedImage> image {getFromCoverFile(_defaultCoverPath, width)};
std::shared_ptr<IEncodedImage> image{ getFromCoverFile(_defaultCoverPath, width) };
_defaultCoverCache[width] = image;
LMS_LOG(COVER, DEBUG) << "Default cache entries = " << _defaultCoverCache.size();
return image;
}
}
}
std::unique_ptr<IEncodedImage>
CoverService::getFromDirectory(const std::filesystem::path& directory, ImageSize width) const
{
const std::multimap<std::string, std::filesystem::path> coverPaths {getCoverPaths(directory)};
std::unique_ptr<IEncodedImage> CoverService::getFromDirectory(const std::filesystem::path& directory, ImageSize width) const
{
const std::multimap<std::string, std::filesystem::path> coverPaths{ getCoverPaths(directory) };
auto tryLoadImageFromFilename = [&](std::string_view fileName)
{
std::unique_ptr<IEncodedImage> image;
auto range {coverPaths.equal_range(std::string {fileName})};
for (auto it {range.first}; it != range.second; ++it)
auto range{ coverPaths.equal_range(std::string {fileName}) };
for (auto it{ range.first }; it != range.second; ++it)
{
image = getFromCoverFile(it->second, width);
if (image)
@@ -239,14 +232,13 @@ CoverService::getFromDirectory(const std::filesystem::path& directory, ImageSize
}
return image;
}
}
std::unique_ptr<IEncodedImage>
CoverService::getFromSameNamedFile(const std::filesystem::path& filePath, ImageSize width) const
{
std::unique_ptr<IEncodedImage> CoverService::getFromSameNamedFile(const std::filesystem::path& filePath, ImageSize width) const
{
std::unique_ptr<IEncodedImage> res;
std::filesystem::path coverPath {filePath};
std::filesystem::path coverPath{ filePath };
for (const std::filesystem::path& extension : _fileExtensions)
{
coverPath.replace_extension(extension);
@@ -260,11 +252,10 @@ CoverService::getFromSameNamedFile(const std::filesystem::path& filePath, ImageS
}
return res;
}
}
bool
CoverService::checkCoverFile(const std::filesystem::path& filePath) const
{
bool CoverService::checkCoverFile(const std::filesystem::path& filePath) const
{
std::error_code ec;
if (!isFileSupported(filePath, _fileExtensions))
@@ -283,11 +274,10 @@ CoverService::checkCoverFile(const std::filesystem::path& filePath) const
}
return true;
}
}
std::multimap<std::string, std::filesystem::path>
CoverService::getCoverPaths(const std::filesystem::path& directoryPath) const
{
std::multimap<std::string, std::filesystem::path> CoverService::getCoverPaths(const std::filesystem::path& directoryPath) const
{
std::multimap<std::string, std::filesystem::path> res;
std::error_code ec;
@@ -295,7 +285,7 @@ CoverService::getCoverPaths(const std::filesystem::path& directoryPath) const
std::filesystem::directory_iterator itEnd;
while (!ec && itPath != itEnd)
{
const std::filesystem::path& path {*itPath};
const std::filesystem::path& path{ *itPath };
if (checkCoverFile(path))
res.emplace(std::filesystem::path{ path }.filename().replace_extension("").string(), path);
@@ -304,11 +294,10 @@ CoverService::getCoverPaths(const std::filesystem::path& directoryPath) const
}
return res;
}
}
std::unique_ptr<IEncodedImage>
CoverService::getFromTrack(const std::filesystem::path& p, ImageSize width) const
{
std::unique_ptr<IEncodedImage> CoverService::getFromTrack(const std::filesystem::path& p, ImageSize width) const
{
std::unique_ptr<IEncodedImage> image;
try
@@ -321,26 +310,24 @@ CoverService::getFromTrack(const std::filesystem::path& p, ImageSize width) cons
}
return image;
}
}
std::shared_ptr<IEncodedImage>
CoverService::getFromTrack(Database::TrackId trackId, ImageSize width)
{
std::shared_ptr<IEncodedImage> CoverService::getFromTrack(Database::TrackId trackId, ImageSize width)
{
return getFromTrack(_db.getTLSSession(), trackId, width, true /* allow release fallback*/);
}
}
std::shared_ptr<IEncodedImage>
CoverService::getFromTrack(Database::Session& dbSession, Database::TrackId trackId, ImageSize width, bool allowReleaseFallback)
{
std::shared_ptr<IEncodedImage> CoverService::getFromTrack(Database::Session& dbSession, Database::TrackId trackId, ImageSize width, bool allowReleaseFallback)
{
using namespace Database;
const CacheEntryDesc cacheEntryDesc {trackId, width};
const CacheEntryDesc cacheEntryDesc{ trackId, width };
std::shared_ptr<IEncodedImage> cover {loadFromCache(cacheEntryDesc)};
std::shared_ptr<IEncodedImage> cover{ loadFromCache(cacheEntryDesc) };
if (cover)
return cover;
if (const std::optional<TrackInfo> trackInfo {getTrackInfo(dbSession, trackId)})
if (const std::optional<TrackInfo> trackInfo{ getTrackInfo(dbSession, trackId) })
{
if (trackInfo->hasCover)
cover = getFromTrack(trackInfo->trackPath, width);
@@ -365,15 +352,14 @@ CoverService::getFromTrack(Database::Session& dbSession, Database::TrackId track
saveToCache(cacheEntryDesc, cover);
return cover;
}
}
std::shared_ptr<IEncodedImage>
CoverService::getFromRelease(Database::ReleaseId releaseId, ImageSize width)
{
std::shared_ptr<IEncodedImage> CoverService::getFromRelease(Database::ReleaseId releaseId, ImageSize width)
{
using namespace Database;
const CacheEntryDesc cacheEntryDesc {releaseId, width};
const CacheEntryDesc cacheEntryDesc{ releaseId, width };
std::shared_ptr<IEncodedImage> cover {loadFromCache(cacheEntryDesc)};
std::shared_ptr<IEncodedImage> cover{ loadFromCache(cacheEntryDesc) };
if (cover)
return cover;
@@ -383,30 +369,28 @@ CoverService::getFromRelease(Database::ReleaseId releaseId, ImageSize width)
std::filesystem::path releaseDirectory;
};
Session& session {_db.getTLSSession()};
Session& session{ _db.getTLSSession() };
auto getReleaseInfo {[&]
auto getReleaseInfo{ [&]
{
std::optional<ReleaseInfo> res;
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
const auto tracks {Track::find(session, Track::FindParameters {}.setRelease(releaseId).setRange({0, 1}).setSortMethod(TrackSortMethod::Release))};
const auto tracks{ Track::find(session, Track::FindParameters {}.setRelease(releaseId).setRange({0, 1}).setSortMethod(TrackSortMethod::Release)) };
if (!tracks.results.empty())
{
if (const Track::pointer track {Track::find(session, tracks.results.front())})
{
res = ReleaseInfo {};
const Track::pointer& track{ tracks.results.front() };
res = ReleaseInfo{};
res->firstTrackId = track->getId();
res->releaseDirectory = track->getPath().parent_path();
}
}
return res;
}};
} };
if (const std::optional<ReleaseInfo> releaseInfo {getReleaseInfo()})
if (const std::optional<ReleaseInfo> releaseInfo{ getReleaseInfo() })
{
cover = getFromDirectory(releaseInfo->releaseDirectory, width);
if (!cover)
@@ -420,50 +404,46 @@ CoverService::getFromRelease(Database::ReleaseId releaseId, ImageSize width)
saveToCache(cacheEntryDesc, cover);
return cover;
}
}
void
CoverService::flushCache()
{
std::unique_lock lock {_cacheMutex};
void CoverService::flushCache()
{
std::unique_lock lock{ _cacheMutex };
LMS_LOG(COVER, DEBUG) << "Cache stats: hits = " << _cacheHits << ", misses = " << _cacheMisses << ", nb entries = " << _cache.size() << ", size = " << _cacheSize;
_cacheHits = 0;
_cacheMisses = 0;
_cacheSize = 0;
_cache.clear();
}
}
void
CoverService::setJpegQuality(unsigned quality)
{
void CoverService::setJpegQuality(unsigned quality)
{
_jpegQuality = Utils::clamp<unsigned>(quality, 1, 100);
LMS_LOG(COVER, INFO) << "JPEG export quality = " << _jpegQuality;
}
}
void
CoverService::saveToCache(const CacheEntryDesc& entryDesc, std::shared_ptr<IEncodedImage> image)
{
std::unique_lock lock {_cacheMutex};
void CoverService::saveToCache(const CacheEntryDesc& entryDesc, std::shared_ptr<IEncodedImage> image)
{
std::unique_lock lock{ _cacheMutex };
while (_cacheSize + image->getDataSize() > _maxCacheSize && !_cache.empty())
{
auto itRandom {Random::pickRandom(_cache)};
auto itRandom{ Random::pickRandom(_cache) };
_cacheSize -= itRandom->second->getDataSize();
_cache.erase(itRandom);
}
_cacheSize += image->getDataSize();
_cache[entryDesc] = image;
}
}
std::shared_ptr<IEncodedImage>
CoverService::loadFromCache(const CacheEntryDesc& entryDesc)
{
std::shared_lock lock {_cacheMutex};
std::shared_ptr<IEncodedImage> CoverService::loadFromCache(const CacheEntryDesc& entryDesc)
{
std::shared_lock lock{ _cacheMutex };
auto it {_cache.find(entryDesc)};
auto it{ _cache.find(entryDesc) };
if (it == std::cend(_cache))
{
++_cacheMisses;
@@ -472,7 +452,7 @@ CoverService::loadFromCache(const CacheEntryDesc& entryDesc)
++_cacheHits;
return it->second;
}
}
} // namespace Cover
src/libs/services/database/impl/Track.cpp
+31 -8
View File
@@ -39,11 +39,12 @@ namespace Database
{
namespace
{
Wt::Dbo::Query<TrackId> createQuery(Session& session, const Track::FindParameters& params)
template <typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, std::string_view itemToSelect, const Track::FindParameters& params)
{
session.checkSharedLocked();
auto query{ session.getDboSession().query<TrackId>(params.distinct ? "SELECT DISTINCT t.id FROM track t" : "SELECT t.id FROM track t") };
auto query{ session.getDboSession().query<ResultType>(params.distinct ? "SELECT DISTINCT " + std::string{ itemToSelect } + " FROM track t" : "SELECT t.id FROM track t") };
assert(params.keywords.empty() || params.name.empty());
for (std::string_view keyword : params.keywords)
@@ -168,6 +169,21 @@ namespace Database
return query;
}
template <typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, const Track::FindParameters& params)
{
std::string_view itemToSelect;
if constexpr (std::is_same_v<ResultType, TrackId>)
itemToSelect = "t.id";
else if constexpr (std::is_same_v<ResultType, Wt::Dbo::ptr<Track>>)
itemToSelect = "t";
else
static_assert("Unhandled type");
return createQuery<ResultType>(session, itemToSelect, params);
}
}
Track::Track(const std::filesystem::path& p)
@@ -257,7 +273,7 @@ namespace Database
return res;
}
RangeResults<TrackId> Track::findTrackMBIDDuplicates(Session& session, Range range)
RangeResults<TrackId> Track::findIdsTrackMBIDDuplicates(Session& session, Range range)
{
session.checkSharedLocked();
@@ -267,7 +283,7 @@ namespace Database
return Utils::execQuery(query, range);
}
RangeResults<TrackId> Track::findWithRecordingMBIDAndMissingFeatures(Session& session, Range range)
RangeResults<TrackId> Track::findIdsWithRecordingMBIDAndMissingFeatures(Session& session, Range range)
{
session.checkSharedLocked();
@@ -295,16 +311,23 @@ namespace Database
return std::vector<ClusterId>(res.begin(), res.end());
}
RangeResults<TrackId> Track::find(Session& session, const FindParameters& parameters)
RangeResults<TrackId> Track::findIds(Session& session, const FindParameters& parameters)
{
session.checkSharedLocked();
auto query{ createQuery(session, parameters) };
auto query{ createQuery<TrackId>(session, parameters) };
return Utils::execQuery(query, parameters.range);
}
RangeResults<TrackId> Track::findSimilarTracks(Session& session, const std::vector<TrackId>& tracks, Range range)
RangeResults<Track::pointer> Track::find(Session& session, const FindParameters& parameters)
{
session.checkSharedLocked();
auto query{ createQuery<Wt::Dbo::ptr<Track>>(session, parameters) };
return Utils::execQuery(query, parameters.range);
}
RangeResults<TrackId> Track::findSimilarTrackIds(Session& session, const std::vector<TrackId>& tracks, Range range)
{
assert(!tracks.empty());
session.checkSharedLocked();
src/libs/services/database/include/services/database/Track.hpp
+6 -6
View File
@@ -21,11 +21,10 @@
#include <chrono>
#include <filesystem>
#include <iostream>
#include <ostream>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_set>
#include <utility>
#include <vector>
@@ -111,12 +110,13 @@ class Track final : public Object<Track, TrackId>
static bool exists(Session& session, TrackId id);
static std::vector<pointer> findByRecordingMBID(Session& session, const UUID& MBID);
static std::vector<pointer> findByMBID(Session& session, const UUID& MBID);
static RangeResults<TrackId> findSimilarTracks(Session& session, const std::vector<TrackId>& trackIds, Range range);
static RangeResults<TrackId> findSimilarTrackIds(Session& session, const std::vector<TrackId>& trackIds, Range range);
static RangeResults<TrackId> find(Session& session, const FindParameters& parameters);
static RangeResults<TrackId> findIds(Session& session, const FindParameters& parameters);
static RangeResults<pointer> find(Session& session, const FindParameters& parameters);
static RangeResults<PathResult> findPaths(Session& session, Range range);
static RangeResults<TrackId> findTrackMBIDDuplicates(Session& session, Range range);
static RangeResults<TrackId> findWithRecordingMBIDAndMissingFeatures(Session& session, Range range);
static RangeResults<TrackId> findIdsTrackMBIDDuplicates(Session& session, Range range);
static RangeResults<TrackId> findIdsWithRecordingMBIDAndMissingFeatures(Session& session, Range range);
// Accessors
void setScanVersion(std::size_t version) { _scanVersion = version; }
src/libs/services/database/test/Artist.cpp
+115 -116
View File
@@ -24,17 +24,17 @@ using namespace Database;
TEST_F(DatabaseFixture, Artist)
{
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
EXPECT_FALSE(Artist::exists(session, 35));
EXPECT_FALSE(Artist::exists(session, 0));
EXPECT_FALSE(Artist::exists(session, 1));
EXPECT_EQ(Artist::getCount(session), 0);
}
ScopedArtist artist {session, "MyArtist"};
ScopedArtist artist{ session, "MyArtist" };
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(artist.get());
EXPECT_FALSE(!artist.get());
@@ -45,13 +45,13 @@ TEST_F(DatabaseFixture, Artist)
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
auto artists {Artist::find(session, Artist::FindParameters {})};
auto artists{ Artist::find(session, Artist::FindParameters {}) };
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
artists = Artist::findAllOrphans(session, Range {});
artists = Artist::findAllOrphans(session, Range{});
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
}
@@ -59,69 +59,69 @@ TEST_F(DatabaseFixture, Artist)
TEST_F(DatabaseFixture, Artist_singleTrack)
{
ScopedTrack track {session, "MyTrack"};
ScopedArtist artist {session, "MyArtist"};
ScopedTrack track{ session, "MyTrack" };
ScopedArtist artist{ session, "MyArtist" };
{
auto transaction {session.createUniqueTransaction()};
auto transaction{ session.createUniqueTransaction() };
track.get().modify()->setName("MyTrackName");
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty());
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
auto artists {track->getArtists({TrackArtistLinkType::Artist})};
auto artists{ track->getArtists({TrackArtistLinkType::Artist}) };
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
ASSERT_EQ(track->getArtistLinks().size(), 1);
auto artistLink {track->getArtistLinks().front()};
auto artistLink{ track->getArtistLinks().front() };
EXPECT_EQ(artistLink->getTrack()->getId(), track.getId());
EXPECT_EQ(artistLink->getArtist()->getId(), artist.getId());
ASSERT_EQ(track->getArtists({TrackArtistLinkType::Artist}).size(), 1);
EXPECT_TRUE(track->getArtists({TrackArtistLinkType::ReleaseArtist}).empty());
ASSERT_EQ(track->getArtists({ TrackArtistLinkType::Artist }).size(), 1);
EXPECT_TRUE(track->getArtists({ TrackArtistLinkType::ReleaseArtist }).empty());
EXPECT_EQ(track->getArtists({}).size(), 1);
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
auto artists {track->getArtistIds({TrackArtistLinkType::Artist})};
auto artists{ track->getArtistIds({TrackArtistLinkType::Artist}) };
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front(), artist.getId());
ASSERT_EQ(track->getArtistIds({TrackArtistLinkType::Artist}).size(), 1);
EXPECT_TRUE(track->getArtistIds({TrackArtistLinkType::ReleaseArtist}).empty());
ASSERT_EQ(track->getArtistIds({ TrackArtistLinkType::Artist }).size(), 1);
EXPECT_TRUE(track->getArtistIds({ TrackArtistLinkType::ReleaseArtist }).empty());
EXPECT_EQ(track->getArtistIds({}).size(), 1);
}
{
auto transaction {session.createSharedTransaction()};
auto tracks {Track::find(session, Track::FindParameters{}.setName("MyTrackName").setArtistName("MyArtist"))};
auto transaction{ session.createSharedTransaction() };
auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackName").setArtistName("MyArtist")) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
}
{
auto transaction {session.createSharedTransaction()};
auto tracks {Track::find(session, Track::FindParameters{}.setName("MyTrackName").setArtistName("MyArtistFoo"))};
auto transaction{ session.createSharedTransaction() };
auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackName").setArtistName("MyArtistFoo")) };
EXPECT_EQ(tracks.results.size(), 0);
}
{
auto transaction {session.createSharedTransaction()};
auto tracks {Track::find(session, Track::FindParameters{}.setName("MyTrackNameFoo").setArtistName("MyArtist"))};
auto transaction{ session.createSharedTransaction() };
auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackNameFoo").setArtistName("MyArtist")) };
EXPECT_EQ(tracks.results.size(), 0);
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Artist::find(session, Artist::FindParameters{}.setTrack(track->getId()))};
auto transaction{ session.createSharedTransaction() };
auto artists{ Artist::find(session, Artist::FindParameters{}.setTrack(track->getId())) };
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
}
@@ -129,10 +129,10 @@ TEST_F(DatabaseFixture, Artist_singleTrack)
TEST_F(DatabaseFixture, Artist_singleTracktMultiRoles)
{
ScopedTrack track {session, "MyTrack"};
ScopedArtist artist {session, "MyArtist"};
ScopedTrack track{ session, "MyTrack" };
ScopedArtist artist{ session, "MyArtist" };
{
auto transaction {session.createUniqueTransaction()};
auto transaction{ session.createUniqueTransaction() };
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::ReleaseArtist);
@@ -140,48 +140,48 @@ TEST_F(DatabaseFixture, Artist_singleTracktMultiRoles)
}
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty());
}
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(Artist::find(session, Artist::FindParameters {}).results.size(), 1);
EXPECT_EQ(Artist::find(session, Artist::FindParameters {}.setLinkType(TrackArtistLinkType::Artist)).results.size(), 1);
EXPECT_EQ(Artist::find(session, Artist::FindParameters {}.setLinkType(TrackArtistLinkType::ReleaseArtist)).results.size(), 1);
EXPECT_EQ(Artist::find(session, Artist::FindParameters {}.setLinkType(TrackArtistLinkType::Writer)).results.size(), 1);
EXPECT_EQ(Artist::find(session, Artist::FindParameters {}.setLinkType(TrackArtistLinkType::Composer)).results.size(), 0);
auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}).results.size(), 1);
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::Artist)).results.size(), 1);
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::ReleaseArtist)).results.size(), 1);
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::Writer)).results.size(), 1);
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::Composer)).results.size(), 0);
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
auto artists {track->getArtists({TrackArtistLinkType::Artist})};
auto artists{ track->getArtists({TrackArtistLinkType::Artist}) };
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
artists = track->getArtists({TrackArtistLinkType::ReleaseArtist});
artists = track->getArtists({ TrackArtistLinkType::ReleaseArtist });
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
EXPECT_EQ(track->getArtistLinks().size(), 3);
auto tracks {Track::find(session, Track::FindParameters {}.setArtist(artist.getId()))};
auto tracks{ Track::findIds(session, Track::FindParameters {}.setArtist(artist.getId())) };
EXPECT_EQ(tracks.results.size(), 1);
tracks = Track::find(session, Track::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::ReleaseArtist}));
tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::ReleaseArtist }));
EXPECT_EQ(tracks.results.size(), 1);
tracks = Track::find(session, Track::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Artist}));
tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Artist }));
EXPECT_EQ(tracks.results.size(), 1);
tracks = Track::find(session, Track::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Writer}));
tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Writer }));
EXPECT_EQ(tracks.results.size(), 1);
tracks = Track::find(session, Track::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Composer}));
tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Composer }));
EXPECT_EQ(tracks.results.size(), 0);
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
EnumSet<TrackArtistLinkType> types{ TrackArtistLink::findUsedTypes(session, artist.getId()) };
EXPECT_TRUE(types.contains(TrackArtistLinkType::ReleaseArtist));
EXPECT_TRUE(types.contains(TrackArtistLinkType::Artist));
@@ -192,84 +192,84 @@ TEST_F(DatabaseFixture, Artist_singleTracktMultiRoles)
TEST_F(DatabaseFixture, Artist_singleTrackMultiArtists)
{
ScopedTrack track {session, "track"};
ScopedArtist artist1 {session, "artist1"};
ScopedArtist artist2 {session, "artist2"};
ScopedTrack track{ session, "track" };
ScopedArtist artist1{ session, "artist1" };
ScopedArtist artist2{ session, "artist2" };
ASSERT_NE(artist1.getId(), artist2.getId());
{
auto transaction {session.createUniqueTransaction()};
auto transaction{ session.createUniqueTransaction() };
TrackArtistLink::create(session, track.get(), artist1.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track.get(), artist2.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty());
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
auto artists {track->getArtists({TrackArtistLinkType::Artist})};
auto artists{ track->getArtists({TrackArtistLinkType::Artist}) };
ASSERT_EQ(artists.size(), 2);
EXPECT_TRUE((artists[0]->getId() == artist1.getId() && artists[1]->getId() == artist2.getId())
|| (artists[0]->getId() == artist2.getId() && artists[1]->getId() == artist1.getId()));
EXPECT_EQ(track->getArtists({}).size(), 2);
EXPECT_EQ(track->getArtists({TrackArtistLinkType::Artist}).size(), 2);
EXPECT_TRUE(track->getArtists({TrackArtistLinkType::ReleaseArtist}).empty());
EXPECT_EQ(Artist::find(session, Artist::FindParameters {}).results.size(), 2);
EXPECT_EQ(Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::Random)).results.size(), 2);
EXPECT_EQ(track->getArtists({ TrackArtistLinkType::Artist }).size(), 2);
EXPECT_TRUE(track->getArtists({ TrackArtistLinkType::ReleaseArtist }).empty());
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}).results.size(), 2);
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setSortMethod(ArtistSortMethod::Random)).results.size(), 2);
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
auto tracks {Track::find(session, Track::FindParameters {}.setArtist(artist1->getId()))};
auto tracks{ Track::findIds(session, Track::FindParameters {}.setArtist(artist1->getId())) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track->getId());
tracks = Track::find(session, Track::FindParameters {}.setArtist(artist2->getId()));
tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist2->getId()));
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track->getId());
tracks = Track::find(session, Track::FindParameters {}.setArtist(artist1->getId(), {TrackArtistLinkType::ReleaseArtist}));
tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist1->getId(), { TrackArtistLinkType::ReleaseArtist }));
EXPECT_EQ(tracks.results.size(), 0);
tracks = Track::find(session, Track::FindParameters {}.setArtist(artist1->getId(), {TrackArtistLinkType::Artist}));
tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist1->getId(), { TrackArtistLinkType::Artist }));
EXPECT_EQ(tracks.results.size(), 1);
tracks = Track::find(session, Track::FindParameters {}.setArtist(artist2->getId(), {TrackArtistLinkType::ReleaseArtist}));
tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist2->getId(), { TrackArtistLinkType::ReleaseArtist }));
EXPECT_EQ(tracks.results.size(), 0);
tracks = Track::find(session, Track::FindParameters {}.setArtist(artist2->getId(), {TrackArtistLinkType::Artist}));
tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist2->getId(), { TrackArtistLinkType::Artist }));
EXPECT_EQ(tracks.results.size(), 1);
}
}
TEST_F(DatabaseFixture, Artist_findByName)
{
ScopedArtist artist {session, "AAA"};
ScopedTrack track {session, "MyTrack"}; // filters does not work on orphans
ScopedArtist artist{ session, "AAA" };
ScopedTrack track{ session, "MyTrack" }; // filters does not work on orphans
{
auto transaction {session.createUniqueTransaction()};
auto transaction{ session.createUniqueTransaction() };
artist.get().modify()->setSortName("ZZZ");
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Artist::find(session, Artist::FindParameters {}.setKeywords({"N"})).results.empty());
EXPECT_TRUE(Artist::find(session, Artist::FindParameters{}.setKeywords({ "N" })).results.empty());
const auto artistsByAAA {Artist::find(session, Artist::FindParameters {}.setKeywords({"A"}))};
const auto artistsByAAA{ Artist::find(session, Artist::FindParameters {}.setKeywords({"A"})) };
ASSERT_EQ(artistsByAAA.results.size(), 1);
EXPECT_EQ(artistsByAAA.results.front(), artist.getId());
const auto artistsByZZZ {Artist::Artist::find(session, Artist::FindParameters {}.setKeywords({"Z"}))};
const auto artistsByZZZ{ Artist::Artist::find(session, Artist::FindParameters {}.setKeywords({"Z"})) };
ASSERT_EQ(artistsByZZZ.results.size(), 1);
EXPECT_EQ(artistsByZZZ.results.front(), artist.getId());
@@ -280,30 +280,30 @@ TEST_F(DatabaseFixture, Artist_findByName)
TEST_F(DatabaseFixture, Artist_findByNameEscaped)
{
ScopedArtist artist1 {session, "MyArtist%"};
ScopedArtist artist2 {session, "%MyArtist"};
ScopedArtist artist3 {session, "%_MyArtist"};
ScopedArtist artist1{ session, "MyArtist%" };
ScopedArtist artist2{ session, "%MyArtist" };
ScopedArtist artist3{ session, "%_MyArtist" };
ScopedArtist artist4 {session, "MyArtist%foo"};
ScopedArtist artist5 {session, "foo%MyArtist"};
ScopedArtist artist6 {session, "%AMyArtist"};
ScopedArtist artist4{ session, "MyArtist%foo" };
ScopedArtist artist5{ session, "foo%MyArtist" };
ScopedArtist artist6{ session, "%AMyArtist" };
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
{
const auto artists {Artist::find(session, "MyArtist%")};
const auto artists{ Artist::find(session, "MyArtist%") };
ASSERT_TRUE(artists.size() == 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
EXPECT_TRUE(Artist::find(session, "MyArtistFoo").empty());
}
{
const auto artists {Artist::find(session, "%MyArtist")};
const auto artists{ Artist::find(session, "%MyArtist") };
ASSERT_TRUE(artists.size() == 1);
EXPECT_EQ(artists.front()->getId(), artist2.getId());
EXPECT_TRUE(Artist::find(session, "FooMyArtist").empty());
}
{
const auto artists {Artist::find(session, "%_MyArtist")};
const auto artists{ Artist::find(session, "%_MyArtist") };
ASSERT_TRUE(artists.size() == 1);
ASSERT_EQ(artists.front()->getId(), artist3.getId());
EXPECT_TRUE(Artist::find(session, "%CMyArtist").empty());
@@ -311,28 +311,28 @@ TEST_F(DatabaseFixture, Artist_findByNameEscaped)
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
{
const auto artists {Artist::find(session, Artist::FindParameters {}.setKeywords({"MyArtist"}))};
const auto artists{ Artist::find(session, Artist::FindParameters {}.setKeywords({"MyArtist"})) };
EXPECT_EQ(artists.results.size(), 6);
}
{
const auto artists {Artist::find(session, Artist::FindParameters {}.setKeywords({"MyArtist%"}).setSortMethod(ArtistSortMethod::ByName))};
const auto artists{ Artist::find(session, Artist::FindParameters {}.setKeywords({"MyArtist%"}).setSortMethod(ArtistSortMethod::ByName)) };
ASSERT_EQ(artists.results.size(), 2);
EXPECT_EQ(artists.results[0], artist1.getId());
EXPECT_EQ(artists.results[1], artist4.getId());
}
{
const auto artists {Artist::find(session, Artist::FindParameters {}.setKeywords({"%MyArtist"}).setSortMethod(ArtistSortMethod::ByName))};
const auto artists{ Artist::find(session, Artist::FindParameters {}.setKeywords({"%MyArtist"}).setSortMethod(ArtistSortMethod::ByName)) };
ASSERT_EQ(artists.results.size(), 2);
EXPECT_EQ(artists.results[0], artist2.getId());
EXPECT_EQ(artists.results[1], artist5.getId());
}
{
const auto artists {Artist::find(session, Artist::FindParameters {}.setKeywords({"_MyArtist"}).setSortMethod(ArtistSortMethod::ByName))};
const auto artists{ Artist::find(session, Artist::FindParameters {}.setKeywords({"_MyArtist"}).setSortMethod(ArtistSortMethod::ByName)) };
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results[0], artist3.getId());
}
@@ -341,21 +341,21 @@ TEST_F(DatabaseFixture, Artist_findByNameEscaped)
TEST_F(DatabaseFixture, Artist_sortMethod)
{
ScopedArtist artistA {session, "artistA"};
ScopedArtist artistB {session, "artistB"};
ScopedArtist artistA{ session, "artistA" };
ScopedArtist artistB{ session, "artistB" };
{
auto transaction {session.createUniqueTransaction()};
auto transaction{ session.createUniqueTransaction() };
artistA.get().modify()->setSortName("sortNameB");
artistB.get().modify()->setSortName("sortNameA");
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
auto allArtistsByName {Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::ByName))};
auto allArtistsBySortName {Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::BySortName))};
auto allArtistsByName{ Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::ByName)) };
auto allArtistsBySortName{ Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::BySortName)) };
ASSERT_EQ(allArtistsByName.results.size(), 2);
EXPECT_EQ(allArtistsByName.results.front(), artistA.getId());
@@ -369,20 +369,20 @@ TEST_F(DatabaseFixture, Artist_sortMethod)
TEST_F(DatabaseFixture, Artist_nonReleaseTracks)
{
ScopedArtist artist {session, "artist"};
ScopedTrack track1 {session, "MyTrack1"};
ScopedTrack track2 {session, "MyTrack2"};
ScopedRelease release{session, "MyRelease"};
ScopedArtist artist{ session, "artist" };
ScopedTrack track1{ session, "MyTrack1" };
ScopedTrack track2{ session, "MyTrack2" };
ScopedRelease release{ session, "MyRelease" };
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
auto tracks {Track::find(session, Track::FindParameters {}.setNonRelease(true).setArtist(artist->getId()))};
auto tracks{ Track::findIds(session, Track::FindParameters {}.setNonRelease(true).setArtist(artist->getId())) };
EXPECT_EQ(tracks.results.size(), 0);
}
{
auto transaction {session.createUniqueTransaction()};
auto transaction{ session.createUniqueTransaction() };
TrackArtistLink::create(session, track1.get(), artist.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track2.get(), artist.get(), TrackArtistLinkType::Artist);
@@ -391,9 +391,9 @@ TEST_F(DatabaseFixture, Artist_nonReleaseTracks)
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
const auto tracks {Track::find(session, Track::FindParameters {}.setArtist(artist.getId()).setNonRelease(true))};
const auto tracks{ Track::findIds(session, Track::FindParameters {}.setArtist(artist.getId()).setNonRelease(true)) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track2.getId());
}
@@ -401,37 +401,36 @@ TEST_F(DatabaseFixture, Artist_nonReleaseTracks)
TEST_F(DatabaseFixture, Artist_findByRelease)
{
ScopedArtist artist {session, "artist"};
ScopedTrack track {session, "MyTrack"};
ScopedRelease release{session, "MyRelease"};
ScopedArtist artist{ session, "artist" };
ScopedTrack track{ session, "MyTrack" };
ScopedRelease release{ session, "MyRelease" };
{
auto transaction {session.createSharedTransaction()};
const auto artists {Artist::find(session, Artist::FindParameters {}.setRelease(release.getId()))};
auto transaction{ session.createSharedTransaction() };
const auto artists{ Artist::find(session, Artist::FindParameters {}.setRelease(release.getId())) };
EXPECT_EQ(artists.results.size(), 0);
}
{
auto transaction {session.createUniqueTransaction()};
auto transaction{ session.createUniqueTransaction() };
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
const auto artists {Artist::find(session, Artist::FindParameters {}.setRelease(release.getId()))};
auto transaction{ session.createSharedTransaction() };
const auto artists{ Artist::find(session, Artist::FindParameters {}.setRelease(release.getId())) };
EXPECT_EQ(artists.results.size(), 0);
}
{
auto transaction {session.createUniqueTransaction()};
auto transaction{ session.createUniqueTransaction() };
track.get().modify()->setRelease(release.get());
}
{
auto transaction {session.createSharedTransaction()};
const auto artists {Artist::find(session, Artist::FindParameters {}.setRelease(release.getId()))};
auto transaction{ session.createSharedTransaction() };
const auto artists{ Artist::find(session, Artist::FindParameters {}.setRelease(release.getId())) };
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
}
}
src/libs/services/database/test/Cluster.cpp
+8 -8
View File
@@ -133,11 +133,11 @@ TEST_F(DatabaseFixture, Cluster_singleTrack)
{
auto transaction{ session.createSharedTransaction() };
auto tracks{ Track::find(session, Track::FindParameters {}.setClusters({cluster1.getId()})) };
auto tracks{ Track::findIds(session, Track::FindParameters {}.setClusters({cluster1.getId()})) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
tracks = Track::find(session, Track::FindParameters{}.setClusters({ cluster2.getId() }));
tracks = Track::findIds(session, Track::FindParameters{}.setClusters({ cluster2.getId() }));
EXPECT_TRUE(tracks.results.empty());
}
@@ -167,7 +167,7 @@ TEST_F(DatabaseFixture, Cluster_singleTrackWithSeveralClusters)
{
auto transaction{ session.createSharedTransaction() };
const auto tracks{ Track::find(session, Track::FindParameters{}.setClusters(clusterIds)) };
const auto tracks{ Track::findIds(session, Track::FindParameters{}.setClusters(clusterIds)) };
EXPECT_TRUE(tracks.results.empty());
}
@@ -180,7 +180,7 @@ TEST_F(DatabaseFixture, Cluster_singleTrackWithSeveralClusters)
{
auto transaction{ session.createSharedTransaction() };
const auto tracks{ Track::find(session, Track::FindParameters{}.setClusters(clusterIds)) };
const auto tracks{ Track::findIds(session, Track::FindParameters{}.setClusters(clusterIds)) };
EXPECT_TRUE(tracks.results.empty());
}
@@ -193,7 +193,7 @@ TEST_F(DatabaseFixture, Cluster_singleTrackWithSeveralClusters)
{
auto transaction{ session.createSharedTransaction() };
const auto tracks{ Track::find(session, Track::FindParameters{}.setClusters(clusterIds)) };
const auto tracks{ Track::findIds(session, Track::FindParameters{}.setClusters(clusterIds)) };
ASSERT_FALSE(tracks.results.empty());
EXPECT_EQ(tracks.results.front(), track.getId());
}
@@ -550,7 +550,7 @@ TEST_F(DatabaseFixture, MultipleTracksSingleClusterSimilarity)
{
auto transaction{ session.createSharedTransaction() };
const auto similarTracks{ Track::findSimilarTracks(session, {tracks.front().getId()}, Range {}) };
const auto similarTracks{ Track::findSimilarTrackIds(session, {tracks.front().getId()}, Range {}) };
EXPECT_EQ(similarTracks.results.size(), tracks.size() - 1);
for (const TrackId similarTrackId : similarTracks.results)
{
@@ -591,14 +591,14 @@ TEST_F(DatabaseFixture, MultipleTracksMultipleClustersSimilarity)
auto transaction{ session.createSharedTransaction() };
{
auto similarTracks{ Track::findSimilarTracks(session, {tracks.back().getId()}, Range {0, 4}) };
auto similarTracks{ Track::findSimilarTrackIds(session, {tracks.back().getId()}, Range {0, 4}) };
EXPECT_EQ(similarTracks.results.size(), 4);
for (const TrackId similarTrackId : similarTracks.results)
EXPECT_TRUE(std::find_if(std::next(std::cbegin(tracks), 5), std::next(std::cend(tracks), -1), [&](const auto& track) { return similarTrackId == track.getId(); }) != std::cend(tracks));
}
{
auto similarTracks{ Track::findSimilarTracks(session, {tracks.front().getId()}, Range {}) };
auto similarTracks{ Track::findSimilarTrackIds(session, {tracks.front().getId()}, Range {}) };
EXPECT_EQ(similarTracks.results.size(), tracks.size() - 1);
for (const TrackId similarTrackId : similarTracks.results)
EXPECT_TRUE(std::find_if(std::next(std::cbegin(tracks), 1), std::cend(tracks), [&](const auto& track) { return similarTrackId == track.getId(); }) != std::cend(tracks));
src/libs/services/database/test/Release.cpp
+9 -9
View File
@@ -78,7 +78,7 @@ TEST_F(DatabaseFixture, Release_singleTrack)
auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
const auto tracks{ Track::find(session, Track::FindParameters {}.setRelease(release.getId())) };
const auto tracks{ Track::findIds(session, Track::FindParameters {}.setRelease(release.getId())) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
}
@@ -92,18 +92,18 @@ TEST_F(DatabaseFixture, Release_singleTrack)
{
auto transaction{ session.createUniqueTransaction() };
auto tracks{ Track::find(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseName")) };
auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseName")) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
}
{
auto transaction{ session.createUniqueTransaction() };
auto tracks{ Track::find(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseFoo")) };
auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseFoo")) };
EXPECT_EQ(tracks.results.size(), 0);
}
{
auto transaction{ session.createUniqueTransaction() };
auto tracks{ Track::find(session, Track::FindParameters{}.setName("MyTrackFoo").setReleaseName("MyReleaseName")) };
auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackFoo").setReleaseName("MyReleaseName")) };
EXPECT_EQ(tracks.results.size(), 0);
}
}
@@ -111,7 +111,7 @@ TEST_F(DatabaseFixture, Release_singleTrack)
{
auto transaction{ session.createUniqueTransaction() };
const auto tracks{ Track::find(session, Track::FindParameters {}.setRelease(release.getId())) };
const auto tracks{ Track::findIds(session, Track::FindParameters {}.setRelease(release.getId())) };
EXPECT_TRUE(tracks.results.empty());
auto releases{ Release::findOrphanIds(session, Range {}) };
@@ -285,8 +285,8 @@ TEST_F(DatabaseFixture, MultiTracksSingleReleaseFirstTrack)
{
auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Track::find(session, Track::FindParameters{}.setRelease(release1.getId())).results.empty());
EXPECT_TRUE(Track::find(session, Track::FindParameters{}.setRelease(release2.getId())).results.empty());
EXPECT_TRUE(Track::findIds(session, Track::FindParameters{}.setRelease(release1.getId())).results.empty());
EXPECT_TRUE(Track::findIds(session, Track::FindParameters{}.setRelease(release2.getId())).results.empty());
}
{
@@ -310,13 +310,13 @@ TEST_F(DatabaseFixture, MultiTracksSingleReleaseFirstTrack)
auto transaction{ session.createSharedTransaction() };
{
const auto tracks{ Track::find(session, Track::FindParameters {}.setRelease(release1.getId()).setSortMethod(TrackSortMethod::Release)) };
const auto tracks{ Track::findIds(session, Track::FindParameters {}.setRelease(release1.getId()).setSortMethod(TrackSortMethod::Release)) };
ASSERT_FALSE(tracks.results.empty());
EXPECT_EQ(tracks.results.front(), track1A.getId());
}
{
const auto tracks{ Track::find(session, Track::FindParameters {}.setRelease(release2.getId()).setSortMethod(TrackSortMethod::Release)) };
const auto tracks{ Track::findIds(session, Track::FindParameters {}.setRelease(release2.getId()).setSortMethod(TrackSortMethod::Release)) };
ASSERT_FALSE(tracks.results.empty());
EXPECT_EQ(tracks.results.front(), track2B.getId());
}
src/libs/services/database/test/StarredTrack.cpp
+9 -9
View File
@@ -37,7 +37,7 @@ TEST_F(DatabaseFixture, StarredTrack)
EXPECT_FALSE(starredTrack);
EXPECT_EQ(StarredTrack::getCount(session), 0);
auto tracks {Track::find(session, Track::FindParameters {})};
auto tracks {Track::findIds(session, Track::FindParameters {})};
EXPECT_EQ(tracks.results.size(), 1);
}
@@ -53,13 +53,13 @@ TEST_F(DatabaseFixture, StarredTrack)
{
auto transaction {session.createSharedTransaction()};
auto tracks {Track::find(session, Track::FindParameters {})};
auto tracks {Track::findIds(session, Track::FindParameters {})};
EXPECT_EQ(tracks.results.size(), 1);
tracks = Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal));
tracks = Track::findIds(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal));
EXPECT_EQ(tracks.results.size(), 1);
tracks = Track::find(session, Track::FindParameters {}.setStarringUser(user2.getId(), FeedbackBackend::Internal));
tracks = Track::findIds(session, Track::FindParameters {}.setStarringUser(user2.getId(), FeedbackBackend::Internal));
EXPECT_EQ(tracks.results.size(), 0);
}
}
@@ -73,11 +73,11 @@ TEST_F(DatabaseFixture, Starredtrack_PendingDestroy)
{
auto transaction {session.createUniqueTransaction()};
auto tracks {Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal))};
auto tracks {Track::findIds(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal))};
EXPECT_EQ(tracks.results.size(), 1);
starredTrack.get().modify()->setSyncState(SyncState::PendingRemove);
tracks = Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal));
tracks = Track::findIds(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal));
EXPECT_EQ(tracks.results.size(), 0);
}
}
@@ -96,7 +96,7 @@ TEST_F(DatabaseFixture, StarredTrack_dateTime)
{
auto transaction {session.createSharedTransaction()};
auto tracks {Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal))};
auto tracks {Track::findIds(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal))};
EXPECT_EQ(tracks.results.size(), 2);
}
@@ -106,7 +106,7 @@ TEST_F(DatabaseFixture, StarredTrack_dateTime)
starredTrack1.get().modify()->setDateTime(dateTime);
starredTrack2.get().modify()->setDateTime(dateTime.addSecs(-1));
auto tracks {Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(TrackSortMethod::StarredDateDesc))};
auto tracks {Track::findIds(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(TrackSortMethod::StarredDateDesc))};
ASSERT_EQ(tracks.results.size(), 2);
EXPECT_EQ(tracks.results[0], starredTrack1->getTrack()->getId());
EXPECT_EQ(tracks.results[1], starredTrack2->getTrack()->getId());
@@ -117,7 +117,7 @@ TEST_F(DatabaseFixture, StarredTrack_dateTime)
starredTrack1.get().modify()->setDateTime(dateTime);
starredTrack2.get().modify()->setDateTime(dateTime.addSecs(1));
auto tracks {Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(TrackSortMethod::StarredDateDesc))};
auto tracks {Track::findIds(session, Track::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(TrackSortMethod::StarredDateDesc))};
ASSERT_EQ(tracks.results.size(), 2);
EXPECT_EQ(tracks.results[0], starredTrack2->getTrack()->getId());
EXPECT_EQ(tracks.results[1], starredTrack1->getTrack()->getId());
src/libs/services/database/test/Track.cpp
+37 -36
View File
@@ -26,21 +26,22 @@ using namespace Database;
TEST_F(DatabaseFixture, Track)
{
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(Track::find(session, Track::FindParameters {}).results.size(), 0);
auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(Track::find(session, Track::FindParameters{}).results.size(), 0);
EXPECT_EQ(Track::findIds(session, Track::FindParameters{}).results.size(), 0);
EXPECT_EQ(Track::getCount(session), 0);
EXPECT_FALSE(Track::exists(session, 0));
}
ScopedTrack track {session, "MyTrackFile"};
ScopedTrack track{ session, "MyTrackFile" };
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(Track::find(session, Track::FindParameters {}).results.size(), 1);
EXPECT_EQ(Track::find(session, Track::FindParameters{}).results.size(), 1);
EXPECT_EQ(Track::getCount(session), 1);
EXPECT_TRUE(Track::exists(session, track.getId()));
auto myTrack {Track::find(session, track.getId())};
auto myTrack{ Track::find(session, track.getId()) };
ASSERT_TRUE(myTrack);
EXPECT_EQ(myTrack->getId(), track.getId());
}
@@ -48,11 +49,11 @@ TEST_F(DatabaseFixture, Track)
TEST_F(DatabaseFixture, MultipleTracks)
{
ScopedTrack track1 {session, "MyTrackFile1"};
ScopedTrack track2 {session, "MyTrackFile2"};
ScopedTrack track1{ session, "MyTrackFile1" };
ScopedTrack track2{ session, "MyTrackFile2" };
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(track1.getId() != track2.getId());
EXPECT_TRUE(track1.get() != track2.get());
@@ -62,15 +63,15 @@ TEST_F(DatabaseFixture, MultipleTracks)
TEST_F(DatabaseFixture, MultipleTracksSearchByFilter)
{
ScopedTrack track1 {session, ""};
ScopedTrack track2 {session, ""};
ScopedTrack track3 {session, ""};
ScopedTrack track4 {session, ""};
ScopedTrack track5 {session, ""};
ScopedTrack track6 {session, ""};
ScopedTrack track1{ session, "" };
ScopedTrack track2{ session, "" };
ScopedTrack track3{ session, "" };
ScopedTrack track4{ session, "" };
ScopedTrack track5{ session, "" };
ScopedTrack track6{ session, "" };
{
auto transaction {session.createUniqueTransaction()};
auto transaction{ session.createUniqueTransaction() };
track1.get().modify()->setName("MyTrack");
track2.get().modify()->setName("MyTrack%");
track3.get().modify()->setName("MyTrack%Foo");
@@ -80,25 +81,25 @@ TEST_F(DatabaseFixture, MultipleTracksSearchByFilter)
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
{
const auto tracks {Track::find(session, Track::FindParameters {}.setKeywords({"Track"}))};
const auto tracks{ Track::findIds(session, Track::FindParameters {}.setKeywords({"Track"})) };
EXPECT_EQ(tracks.results.size(), 6);
}
{
const auto tracks {Track::find(session, Track::FindParameters {}.setKeywords({"MyTrack"}))};
const auto tracks{ Track::findIds(session, Track::FindParameters {}.setKeywords({"MyTrack"})) };
EXPECT_EQ(tracks.results.size(), 5);
EXPECT_TRUE(std::none_of(std::cbegin(tracks.results), std::cend(tracks.results), [&](const TrackId trackId) { return trackId == track6.getId(); }));
}
{
const auto tracks {Track::find(session, Track::FindParameters {}.setKeywords({"MyTrack%"}))};
const auto tracks{ Track::findIds(session, Track::FindParameters {}.setKeywords({"MyTrack%"})) };
ASSERT_EQ(tracks.results.size(), 2);
EXPECT_EQ(tracks.results[0], track2.getId());
EXPECT_EQ(tracks.results[1], track3.getId());
}
{
const auto tracks {Track::find(session, Track::FindParameters {}.setKeywords({"%MyTrack"}))};
const auto tracks{ Track::findIds(session, Track::FindParameters {}.setKeywords({"%MyTrack"})) };
ASSERT_EQ(tracks.results.size(), 2);
EXPECT_EQ(tracks.results[0], track4.getId());
EXPECT_EQ(tracks.results[1], track5.getId());
@@ -108,22 +109,22 @@ TEST_F(DatabaseFixture, MultipleTracksSearchByFilter)
TEST_F(DatabaseFixture, Track_date)
{
ScopedTrack track {session, "MyTrack"};
ScopedTrack track{ session, "MyTrack" };
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(track->getYear(), std::nullopt);
EXPECT_EQ(track->getOriginalYear(), std::nullopt);
}
{
auto transaction {session.createUniqueTransaction()};
track.get().modify()->setDate(Wt::WDate {1995, 5, 5});
track.get().modify()->setOriginalDate(Wt::WDate {1994, 2, 2});
auto transaction{ session.createUniqueTransaction() };
track.get().modify()->setDate(Wt::WDate{ 1995, 5, 5 });
track.get().modify()->setOriginalDate(Wt::WDate{ 1994, 2, 2 });
}
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(track->getYear(), 1995);
EXPECT_EQ(track->getOriginalYear(), 1994);
}
@@ -131,30 +132,30 @@ TEST_F(DatabaseFixture, Track_date)
TEST_F(DatabaseFixture, Track_writtenAfter)
{
ScopedTrack track {session, "MyTrack"};
ScopedTrack track{ session, "MyTrack" };
const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 1}, Wt::WTime {12, 30, 20}};
const Wt::WDateTime dateTime{ Wt::WDate {1950, 1, 1}, Wt::WTime {12, 30, 20} };
{
auto transaction {session.createUniqueTransaction()};
auto transaction{ session.createUniqueTransaction() };
track.get().modify()->setLastWriteTime(dateTime);
}
{
auto transaction {session.createSharedTransaction()};
const auto tracks {Track::find(session, Track::FindParameters {})};
auto transaction{ session.createSharedTransaction() };
const auto tracks{ Track::findIds(session, Track::FindParameters {}) };
EXPECT_EQ(tracks.results.size(), 1);
}
{
auto transaction {session.createSharedTransaction()};
const auto tracks {Track::find(session, Track::FindParameters {}.setWrittenAfter(dateTime.addSecs(-1)))};
auto transaction{ session.createSharedTransaction() };
const auto tracks{ Track::findIds(session, Track::FindParameters {}.setWrittenAfter(dateTime.addSecs(-1))) };
EXPECT_EQ(tracks.results.size(), 1);
}
{
auto transaction {session.createSharedTransaction()};
const auto tracks {Track::find(session, Track::FindParameters {}.setWrittenAfter(dateTime.addSecs(+1)))};
auto transaction{ session.createSharedTransaction() };
const auto tracks{ Track::findIds(session, Track::FindParameters {}.setWrittenAfter(dateTime.addSecs(+1))) };
EXPECT_EQ(tracks.results.size(), 0);
}
}
src/libs/services/database/test/TrackList.cpp
+4 -4
View File
@@ -49,10 +49,10 @@ TEST_F(DatabaseFixture, SingleTrackListSingleTrack)
{
auto transaction {session.createSharedTransaction()};
auto tracks {Track::find(session, Track::FindParameters {}.setTrackList(trackList1.getId()))};
auto tracks {Track::findIds(session, Track::FindParameters {}.setTrackList(trackList1.getId()))};
EXPECT_EQ(tracks.results.size(), 0);
tracks = Track::find(session, Track::FindParameters {}.setTrackList(trackList2.getId()));
tracks = Track::findIds(session, Track::FindParameters {}.setTrackList(trackList2.getId()));
EXPECT_EQ(tracks.results.size(), 0);
}
@@ -65,11 +65,11 @@ TEST_F(DatabaseFixture, SingleTrackListSingleTrack)
{
auto transaction {session.createSharedTransaction()};
auto tracks {Track::find(session, Track::FindParameters {}.setTrackList(trackList1.getId()))};
auto tracks {Track::findIds(session, Track::FindParameters {}.setTrackList(trackList1.getId()))};
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
tracks = Track::find(session, Track::FindParameters {}.setTrackList(trackList2.getId()));
tracks = Track::findIds(session, Track::FindParameters {}.setTrackList(trackList2.getId()));
EXPECT_EQ(tracks.results.size(), 0);
}
}
src/libs/services/feedback/impl/FeedbackService.cpp
+1 -1
View File
@@ -179,7 +179,7 @@ namespace Feedback
Session& session{ _db.getTLSSession() };
auto transaction{ session.createSharedTransaction() };
return Track::find(session, params);
return Track::findIds(session, params);
}
} // ns Feedback
src/libs/services/recommendation/impl/PlaylistGeneratorService.cpp
+13 -16
View File
@@ -32,36 +32,34 @@ namespace Recommendation
{
using namespace Database;
std::unique_ptr<IPlaylistGeneratorService>
createPlaylistGeneratorService(Db& db, Recommendation::IRecommendationService& recommendationService)
std::unique_ptr<IPlaylistGeneratorService> createPlaylistGeneratorService(Db& db, Recommendation::IRecommendationService& recommendationService)
{
return std::make_unique<PlaylistGeneratorService>(db, recommendationService);
}
PlaylistGeneratorService::PlaylistGeneratorService(Db& db, Recommendation::IRecommendationService& recommendationService)
: _db {db}
, _recommendationService {recommendationService}
: _db{ db }
, _recommendationService{ recommendationService }
{
_constraints.push_back(std::make_unique<PlaylistGeneratorConstraint::ConsecutiveArtists>(_db));
_constraints.push_back(std::make_unique<PlaylistGeneratorConstraint::ConsecutiveReleases>(_db));
_constraints.push_back(std::make_unique<PlaylistGeneratorConstraint::DuplicateTracks>());
}
std::vector<TrackId>
PlaylistGeneratorService::extendPlaylist(TrackListId tracklistId, std::size_t maxCount) const
std::vector<TrackId> PlaylistGeneratorService::extendPlaylist(TrackListId tracklistId, std::size_t maxCount) const
{
LMS_LOG(RECOMMENDATION, DEBUG) << "Requested to extend playlist by " << maxCount << " similar tracks";
// supposed to be ordered from most similar to least similar
std::vector<TrackId> similarTracks {_recommendationService.findSimilarTracks(tracklistId, maxCount * 2)}; // ask for more tracks than we need as it will be easier to respect constraints
std::vector<TrackId> similarTracks{ _recommendationService.findSimilarTracks(tracklistId, maxCount * 2) }; // ask for more tracks than we need as it will be easier to respect constraints
const std::vector<TrackId> startingTracks {getTracksFromTrackList(tracklistId)};
const std::vector<TrackId> startingTracks{ getTracksFromTrackList(tracklistId) };
std::vector<TrackId> finalResult = startingTracks;
finalResult.reserve(startingTracks.size() + maxCount);
std::vector<float> scores;
for (std::size_t i {}; i < maxCount; ++i)
for (std::size_t i{}; i < maxCount; ++i)
{
if (similarTracks.empty())
break;
@@ -69,7 +67,7 @@ namespace Recommendation
scores.resize(similarTracks.size(), {});
// select the similar track that has the best score
for (std::size_t trackIndex {}; trackIndex < similarTracks.size(); ++trackIndex)
for (std::size_t trackIndex{}; trackIndex < similarTracks.size(); ++trackIndex)
{
using namespace Database::Debug;
@@ -87,7 +85,7 @@ namespace Recommendation
}
// get the best score
const std::size_t bestScoreIndex {static_cast<std::size_t>(std::distance(std::cbegin(scores), std::min_element(std::cbegin(scores), std::cend(scores))))};
const std::size_t bestScoreIndex{ static_cast<std::size_t>(std::distance(std::cbegin(scores), std::min_element(std::cbegin(scores), std::cend(scores)))) };
finalResult.push_back(similarTracks[bestScoreIndex]);
similarTracks.erase(std::begin(similarTracks) + bestScoreIndex);
@@ -97,20 +95,19 @@ namespace Recommendation
return std::vector(std::cbegin(finalResult) + startingTracks.size(), std::cend(finalResult));
}
TrackContainer
PlaylistGeneratorService::getTracksFromTrackList(Database::TrackListId tracklistId) const
TrackContainer PlaylistGeneratorService::getTracksFromTrackList(Database::TrackListId tracklistId) const
{
TrackContainer tracks;
Session& dbSession {_db.getTLSSession()};
auto transaction {dbSession.createSharedTransaction()};
Session& dbSession{ _db.getTLSSession() };
auto transaction{ dbSession.createSharedTransaction() };
Track::FindParameters params;
params.setTrackList(tracklistId);
params.setSortMethod(TrackSortMethod::TrackList);
params.setDistinct(false);
for (const TrackId trackId : Track::find(dbSession, params).results)
for (const TrackId trackId : Track::findIds(dbSession, params).results)
tracks.push_back(trackId);
return tracks;
src/libs/services/recommendation/impl/clusters/ClustersEngine.cpp
+1 -1
View File
@@ -44,7 +44,7 @@ namespace Recommendation {
Session& dbSession{ _db.getTLSSession() };
auto transaction{ dbSession.createSharedTransaction() };
const auto similarTrackIds{ Track::findSimilarTracks(dbSession, trackIds, Range {0, maxCount}) };
const auto similarTrackIds{ Track::findSimilarTrackIds(dbSession, trackIds, Range {0, maxCount}) };
return std::move(similarTrackIds.results);
}
src/libs/services/scanner/impl/ScanStepCheckDuplicatedDbFiles.cpp
+1 -1
View File
@@ -37,7 +37,7 @@ namespace Scanner
Session& session {_db.getTLSSession()};
auto transaction {session.createSharedTransaction()};
const RangeResults<TrackId> tracks = Track::findTrackMBIDDuplicates(session, Range {});
const RangeResults<TrackId> tracks = Track::findIdsTrackMBIDDuplicates(session, Range {});
for (const TrackId trackId : tracks.results)
{
const Track::pointer track {Track::find(session, trackId)};
src/libs/services/scrobbling/impl/listenbrainz/ListensSynchronizer.cpp
+82 -101
View File
@@ -44,18 +44,17 @@ namespace
{
using namespace Scrobbling::ListenBrainz;
std::optional<Wt::Json::Object>
listenToJsonPayload(Database::Session& session, const Scrobbling::Listen& listen, const Wt::WDateTime& timePoint)
std::optional<Wt::Json::Object> listenToJsonPayload(Database::Session& session, const Scrobbling::Listen& listen, const Wt::WDateTime& timePoint)
{
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
const Database::Track::pointer track {Database::Track::find(session, listen.trackId)};
const Database::Track::pointer track{ Database::Track::find(session, listen.trackId) };
if (!track)
return std::nullopt;
auto artists {track->getArtists({Database::TrackArtistLinkType::Artist})};
auto artists{ track->getArtists({Database::TrackArtistLinkType::Artist}) };
if (artists.empty())
artists = track->getArtists({Database::TrackArtistLinkType::ReleaseArtist});
artists = track->getArtists({ Database::TrackArtistLinkType::ReleaseArtist });
if (artists.empty())
{
@@ -67,72 +66,70 @@ namespace
additionalInfo["listening_from"] = "LMS";
if (track->getRelease())
{
if (auto MBID {track->getRelease()->getMBID()})
additionalInfo["release_mbid"] = Wt::Json::Value {std::string {MBID->getAsString()}};
if (auto MBID{ track->getRelease()->getMBID() })
additionalInfo["release_mbid"] = Wt::Json::Value{ std::string {MBID->getAsString()} };
}
{
Wt::Json::Array artistMBIDs;
for (const Database::Artist::pointer& artist : artists)
{
if (auto MBID {artist->getMBID()})
artistMBIDs.push_back(Wt::Json::Value {std::string {MBID->getAsString()}});
if (auto MBID{ artist->getMBID() })
artistMBIDs.push_back(Wt::Json::Value{ std::string {MBID->getAsString()} });
}
if (!artistMBIDs.empty())
additionalInfo["artist_mbids"] = std::move(artistMBIDs);
}
if (auto MBID {track->getTrackMBID()})
additionalInfo["track_mbid"] = Wt::Json::Value {std::string {MBID->getAsString()}};
if (auto MBID{ track->getTrackMBID() })
additionalInfo["track_mbid"] = Wt::Json::Value{ std::string {MBID->getAsString()} };
if (auto MBID {track->getRecordingMBID()})
additionalInfo["recording_mbid"] = Wt::Json::Value {std::string {MBID->getAsString()}};
if (auto MBID{ track->getRecordingMBID() })
additionalInfo["recording_mbid"] = Wt::Json::Value{ std::string {MBID->getAsString()} };
if (const std::optional<std::size_t> trackNumber {track->getTrackNumber()})
additionalInfo["tracknumber"] = Wt::Json::Value {static_cast<long long int>(*trackNumber)};
if (const std::optional<std::size_t> trackNumber{ track->getTrackNumber() })
additionalInfo["tracknumber"] = Wt::Json::Value{ static_cast<long long int>(*trackNumber) };
Wt::Json::Object trackMetadata;
trackMetadata["additional_info"] = std::move(additionalInfo);
trackMetadata["artist_name"] = Wt::Json::Value {artists.front()->getName()};
trackMetadata["track_name"] = Wt::Json::Value {track->getName()};
trackMetadata["artist_name"] = Wt::Json::Value{ artists.front()->getName() };
trackMetadata["track_name"] = Wt::Json::Value{ track->getName() };
if (track->getRelease())
trackMetadata["release_name"] = Wt::Json::Value {track->getRelease()->getName()};
trackMetadata["release_name"] = Wt::Json::Value{ track->getRelease()->getName() };
Wt::Json::Object payload;
payload["track_metadata"] = std::move(trackMetadata);
if (timePoint.isValid())
payload["listened_at"] = Wt::Json::Value {static_cast<long long int>(timePoint.toTime_t())};
payload["listened_at"] = Wt::Json::Value{ static_cast<long long int>(timePoint.toTime_t()) };
return payload;
}
std::string
listenToJsonString(Database::Session& session, const Scrobbling::Listen& listen, const Wt::WDateTime& timePoint, std::string_view listenType)
std::string listenToJsonString(Database::Session& session, const Scrobbling::Listen& listen, const Wt::WDateTime& timePoint, std::string_view listenType)
{
std::string res;
std::optional<Wt::Json::Object> payload {listenToJsonPayload(session, listen, timePoint)};
std::optional<Wt::Json::Object> payload{ listenToJsonPayload(session, listen, timePoint) };
if (!payload)
return res;
Wt::Json::Object root;
root["listen_type"] = Wt::Json::Value {std::string {listenType}};
root["payload"] = Wt::Json::Array {std::move(*payload)};
root["listen_type"] = Wt::Json::Value{ std::string {listenType} };
root["payload"] = Wt::Json::Array{ std::move(*payload) };
res = Wt::Json::serialize(root);
return res;
}
std::optional<std::size_t>
parseListenCount(std::string_view msgBody)
std::optional<std::size_t> parseListenCount(std::string_view msgBody)
{
try
{
Wt::Json::Object root;
Wt::Json::parse(std::string {msgBody}, root);
Wt::Json::parse(std::string{ msgBody }, root);
const Wt::Json::Object& payload {static_cast<const Wt::Json::Object&>(root.get("payload"))};
const Wt::Json::Object& payload{ static_cast<const Wt::Json::Object&>(root.get("payload")) };
return static_cast<int>(payload.get("count"));
}
catch (const Wt::WException& e)
@@ -142,17 +139,16 @@ namespace
}
}
Database::TrackId
tryGetMatchingTrack(Database::Session& session, const Listen& listen)
Database::TrackId tryGetMatchingTrack(Database::Session& session, const Listen& listen)
{
using namespace Database;
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
// first try to match using track MBID, and then fallback on possibly ambiguous info
if (listen.trackMBID)
{
const auto tracks {Track::findByMBID(session, *listen.trackMBID)};
const auto tracks{ Track::findByMBID(session, *listen.trackMBID) };
// if duplicated files, do not record it (let the user correct its database)
if (tracks.size() == 1)
{
@@ -168,7 +164,7 @@ namespace
if (listen.recordingMBID)
{
const auto tracks {Track::findByRecordingMBID(session, *listen.recordingMBID)};
const auto tracks{ Track::findByRecordingMBID(session, *listen.recordingMBID) };
// if duplicated files, do not record it (let the user correct its database)
if (tracks.size() == 1)
{
@@ -192,7 +188,7 @@ namespace
if (listen.trackNumber)
params.setTrackNumber(*listen.trackNumber);
const auto tracks {Track::find(session, params)};
const auto tracks{ Track::findIds(session, params) };
// conservative behavior: in case of multiple matches: reject
if (tracks.results.size() == 1)
{
@@ -213,39 +209,36 @@ namespace
namespace Scrobbling::ListenBrainz
{
ListensSynchronizer::ListensSynchronizer(boost::asio::io_context& ioContext, Database::Db& db, Http::IClient& client)
: _ioContext {ioContext}
, _db {db}
, _client {client}
, _maxSyncListenCount {Service<IConfig>::get()->getULong("listenbrainz-max-sync-listen-count", 1000)}
, _syncListensPeriod {Service<IConfig>::get()->getULong("listenbrainz-sync-listens-period-hours", 1)}
: _ioContext{ ioContext }
, _db{ db }
, _client{ client }
, _maxSyncListenCount{ Service<IConfig>::get()->getULong("listenbrainz-max-sync-listen-count", 1000) }
, _syncListensPeriod{ Service<IConfig>::get()->getULong("listenbrainz-sync-listens-period-hours", 1) }
{
LOG(INFO) << "Starting Listens synchronizer, maxSyncListenCount = " << _maxSyncListenCount << ", _syncListensPeriod = " << _syncListensPeriod.count() << " hours";
scheduleSync(std::chrono::seconds {30});
scheduleSync(std::chrono::seconds{ 30 });
}
void
ListensSynchronizer::enqueListen(const TimedListen& listen)
void ListensSynchronizer::enqueListen(const TimedListen& listen)
{
assert(listen.listenedAt.isValid());
enqueListen(listen, listen.listenedAt);
}
void
ListensSynchronizer::enqueListenNow(const Scrobbling::Listen& listen)
void ListensSynchronizer::enqueListenNow(const Scrobbling::Listen& listen)
{
enqueListen(listen, {});
}
void
ListensSynchronizer::enqueListen(const Scrobbling::Listen& listen, const Wt::WDateTime& timePoint)
void ListensSynchronizer::enqueListen(const Scrobbling::Listen& listen, const Wt::WDateTime& timePoint)
{
Http::ClientPOSTRequestParameters request;
request.relativeUrl = "/1/submit-listens";
if (timePoint.isValid())
{
const TimedListen timedListen {listen, timePoint};
const TimedListen timedListen{ listen, timePoint };
// We want the listen to be sent again later in case of failure, so we just save it as pending send
saveListen(timedListen, Database::SyncState::PendingAdd);
@@ -256,7 +249,7 @@ namespace Scrobbling::ListenBrainz
{
if (saveListen(timedListen, Database::SyncState::Synchronized))
{
UserContext& context {getUserContext(listen.userId)};
UserContext& context{ getUserContext(listen.userId) };
if (context.listenCount)
(*context.listenCount)++;
}
@@ -271,14 +264,14 @@ namespace Scrobbling::ListenBrainz
// don't retry on failure
}
std::string bodyText {listenToJsonString(_db.getTLSSession(), listen, timePoint, timePoint.isValid() ? "single" : "playing_now")};
std::string bodyText{ listenToJsonString(_db.getTLSSession(), listen, timePoint, timePoint.isValid() ? "single" : "playing_now") };
if (bodyText.empty())
{
LOG(DEBUG) << "Cannot convert listen to json: skipping";
return;
}
const std::optional<UUID> listenBrainzToken {Utils::getListenBrainzToken(_db.getTLSSession(), listen.userId)};
const std::optional<UUID> listenBrainzToken{ Utils::getListenBrainzToken(_db.getTLSSession(), listen.userId) };
if (!listenBrainzToken)
{
LOG(DEBUG) << "No listenbrainz token found: skipping";
@@ -286,27 +279,26 @@ namespace Scrobbling::ListenBrainz
}
request.message.addBodyText(bodyText);
request.message.addHeader("Authorization", "Token " + std::string {listenBrainzToken->getAsString()});
request.message.addHeader("Authorization", "Token " + std::string{ listenBrainzToken->getAsString() });
request.message.addHeader("Content-Type", "application/json");
_client.sendPOSTRequest(std::move(request));
}
bool
ListensSynchronizer::saveListen(const TimedListen& listen, Database::SyncState scrobblingState)
bool ListensSynchronizer::saveListen(const TimedListen& listen, Database::SyncState scrobblingState)
{
using namespace Database;
Session& session {_db.getTLSSession()};
auto transaction {session.createUniqueTransaction()}; // TODO: unique only if needed
Session& session{ _db.getTLSSession() };
auto transaction{ session.createUniqueTransaction() }; // TODO: unique only if needed
Database::Listen::pointer dbListen {Database::Listen::find(session, listen.userId, listen.trackId, Database::ScrobblingBackend::ListenBrainz, listen.listenedAt)};
Database::Listen::pointer dbListen{ Database::Listen::find(session, listen.userId, listen.trackId, Database::ScrobblingBackend::ListenBrainz, listen.listenedAt) };
if (!dbListen)
{
const User::pointer user {User::find(session, listen.userId)};
const User::pointer user{ User::find(session, listen.userId) };
if (!user)
return false;
const Track::pointer track {Track::find(session, listen.trackId)};
const Track::pointer track{ Track::find(session, listen.trackId) };
if (!track)
return false;
@@ -325,27 +317,26 @@ namespace Scrobbling::ListenBrainz
return true;
}
void
ListensSynchronizer::enquePendingListens()
void ListensSynchronizer::enquePendingListens()
{
std::vector<TimedListen> pendingListens;
{
Database::Session& session {_db.getTLSSession()};
Database::Session& session{ _db.getTLSSession() };
auto transaction {session.createUniqueTransaction()};
auto transaction{ session.createUniqueTransaction() };
Database::Listen::FindParameters params;
params.setScrobblingBackend(Database::ScrobblingBackend::ListenBrainz)
.setSyncState(Database::SyncState::PendingAdd)
.setRange(Database::Range {0, 100}); // don't flood too much?
.setRange(Database::Range{ 0, 100 }); // don't flood too much?
const Database::RangeResults results {Database::Listen::find(session, params)};
const Database::RangeResults results{ Database::Listen::find(session, params) };
pendingListens.reserve(results.results.size());
for (Database::ListenId listenId : results.results)
{
const Database::Listen::pointer listen {Database::Listen::find(session, listenId)};
const Database::Listen::pointer listen{ Database::Listen::find(session, listenId) };
TimedListen timedListen;
timedListen.listenedAt = listen->getDateTime();
@@ -362,12 +353,11 @@ namespace Scrobbling::ListenBrainz
enqueListen(pendingListen);
}
ListensSynchronizer::UserContext&
ListensSynchronizer::getUserContext(Database::UserId userId)
ListensSynchronizer::UserContext& ListensSynchronizer::getUserContext(Database::UserId userId)
{
assert(_strand.running_in_this_thread());
auto itContext {_userContexts.find(userId)};
auto itContext{ _userContexts.find(userId) };
if (itContext == std::cend(_userContexts))
{
std::tie(itContext, std::ignore) = _userContexts.emplace(userId, userId);
@@ -376,8 +366,7 @@ namespace Scrobbling::ListenBrainz
return itContext->second;
}
bool
ListensSynchronizer::isSyncing() const
bool ListensSynchronizer::isSyncing() const
{
return std::any_of(std::cbegin(_userContexts), std::cend(_userContexts), [](const auto& contextEntry)
{
@@ -385,15 +374,14 @@ namespace Scrobbling::ListenBrainz
});
}
void
ListensSynchronizer::scheduleSync(std::chrono::seconds fromNow)
void ListensSynchronizer::scheduleSync(std::chrono::seconds fromNow)
{
if (_syncListensPeriod.count() == 0 || _maxSyncListenCount == 0)
return;
LOG(DEBUG) << "Scheduled sync in " << fromNow.count() << " seconds...";
_syncTimer.expires_after(fromNow);
_syncTimer.async_wait(boost::asio::bind_executor(_strand, [this] (const boost::system::error_code& ec)
_syncTimer.async_wait(boost::asio::bind_executor(_strand, [this](const boost::system::error_code& ec)
{
if (ec == boost::asio::error::operation_aborted)
{
@@ -402,15 +390,14 @@ namespace Scrobbling::ListenBrainz
}
else if (ec)
{
throw Exception {"GetListens timer failure: " + std::string {ec.message()} };
throw Exception{ "GetListens timer failure: " + std::string {ec.message()} };
}
startSync();
}));
}
void
ListensSynchronizer::startSync()
void ListensSynchronizer::startSync()
{
LOG(DEBUG) << "Starting sync!";
@@ -420,8 +407,8 @@ namespace Scrobbling::ListenBrainz
Database::RangeResults<Database::UserId> userIds;
{
Database::Session& session {_db.getTLSSession()};
auto transaction {session.createSharedTransaction()};
Database::Session& session{ _db.getTLSSession() };
auto transaction{ session.createSharedTransaction() };
userIds = Database::User::find(_db.getTLSSession(), Database::User::FindParameters{}.setScrobblingBackend(Database::ScrobblingBackend::ListenBrainz));
}
@@ -432,8 +419,7 @@ namespace Scrobbling::ListenBrainz
scheduleSync(_syncListensPeriod);
}
void
ListensSynchronizer::startSync(UserContext& context)
void ListensSynchronizer::startSync(UserContext& context)
{
context.syncing = true;
context.listenBrainzUserName = "";
@@ -445,8 +431,7 @@ namespace Scrobbling::ListenBrainz
enqueValidateToken(context);
}
void
ListensSynchronizer::onSyncEnded(UserContext& context)
void ListensSynchronizer::onSyncEnded(UserContext& context)
{
_strand.dispatch([this, &context]
{
@@ -458,12 +443,11 @@ namespace Scrobbling::ListenBrainz
});
}
void
ListensSynchronizer::enqueValidateToken(UserContext& context)
void ListensSynchronizer::enqueValidateToken(UserContext& context)
{
assert(context.listenBrainzUserName.empty());
const std::optional<UUID> listenBrainzToken {Utils::getListenBrainzToken(_db.getTLSSession(), context.userId)};
const std::optional<UUID> listenBrainzToken{ Utils::getListenBrainzToken(_db.getTLSSession(), context.userId) };
if (!listenBrainzToken)
{
onSyncEnded(context);
@@ -474,7 +458,7 @@ namespace Scrobbling::ListenBrainz
request.priority = Http::ClientRequestParameters::Priority::Low;
request.relativeUrl = "/1/validate-token";
request.headers = { {"Authorization", "Token " + std::string {listenBrainzToken->getAsString()}} };
request.onSuccessFunc = [this, &context] (std::string_view msgBody)
request.onSuccessFunc = [this, &context](std::string_view msgBody)
{
context.listenBrainzUserName = Utils::parseValidateToken(msgBody);
if (context.listenBrainzUserName.empty())
@@ -492,15 +476,14 @@ namespace Scrobbling::ListenBrainz
_client.sendGETRequest(std::move(request));
}
void
ListensSynchronizer::enqueGetListenCount(UserContext& context)
void ListensSynchronizer::enqueGetListenCount(UserContext& context)
{
assert(!context.listenBrainzUserName.empty());
Http::ClientGETRequestParameters request;
request.relativeUrl = "/1/user/" + std::string {context.listenBrainzUserName} + "/listen-count";
request.relativeUrl = "/1/user/" + std::string{ context.listenBrainzUserName } + "/listen-count";
request.priority = Http::ClientRequestParameters::Priority::Low;
request.onSuccessFunc = [=, &context] (std::string_view msgBody)
request.onSuccessFunc = [=, &context](std::string_view msgBody)
{
_strand.dispatch([=, &context]
{
@@ -508,7 +491,7 @@ namespace Scrobbling::ListenBrainz
if (listenCount)
LOG(DEBUG) << "Listen count for listenbrainz user '" << context.listenBrainzUserName << "' = " << *listenCount;
bool needSync {listenCount && (!context.listenCount || *context.listenCount != *listenCount)};
bool needSync{ listenCount && (!context.listenCount || *context.listenCount != *listenCount) };
context.listenCount = listenCount;
if (!needSync)
@@ -529,15 +512,14 @@ namespace Scrobbling::ListenBrainz
_client.sendGETRequest(std::move(request));
}
void
ListensSynchronizer::enqueGetListens(UserContext& context)
void ListensSynchronizer::enqueGetListens(UserContext& context)
{
assert(!context.listenBrainzUserName.empty());
Http::ClientGETRequestParameters request;
request.relativeUrl = "/1/user/" + context.listenBrainzUserName + "/listens?max_ts=" + std::to_string(context.maxDateTime.toTime_t());
request.priority = Http::ClientRequestParameters::Priority::Low;
request.onSuccessFunc = [=, &context] (std::string_view msgBody)
request.onSuccessFunc = [=, &context](std::string_view msgBody)
{
processGetListensResponse(msgBody, context);
if (context.fetchedListenCount >= _maxSyncListenCount || !context.maxDateTime.isValid())
@@ -556,13 +538,12 @@ namespace Scrobbling::ListenBrainz
_client.sendGETRequest(std::move(request));
}
void
ListensSynchronizer::processGetListensResponse(std::string_view msgBody, UserContext& context)
void ListensSynchronizer::processGetListensResponse(std::string_view msgBody, UserContext& context)
{
Database::Session& session {_db.getTLSSession()};
Database::Session& session{ _db.getTLSSession() };
context.maxDateTime = {}; // invalidate to break in case no more listens are fetched
ListensParser::Result result {ListensParser::parse(msgBody)};
ListensParser::Result result{ ListensParser::parse(msgBody) };
context.fetchedListenCount += result.listenCount;
for (const Listen& parsedListen : result.listens)
@@ -577,11 +558,11 @@ namespace Scrobbling::ListenBrainz
if (!context.maxDateTime.isValid() || context.maxDateTime > parsedListen.listenedAt)
context.maxDateTime = parsedListen.listenedAt;
if (const Database::TrackId trackId {tryGetMatchingTrack(session, parsedListen)}; trackId.isValid())
if (const Database::TrackId trackId{ tryGetMatchingTrack(session, parsedListen) }; trackId.isValid())
{
context.matchedListenCount++;
const Scrobbling::TimedListen listen {{context.userId, trackId}, parsedListen.listenedAt};
const Scrobbling::TimedListen listen{ {context.userId, trackId}, parsedListen.listenedAt };
if (saveListen(listen, Database::SyncState::Synchronized))
context.importedListenCount++;
}
src/libs/subsonic/impl/entrypoints/AlbumSongLists.cpp
+4 -10
View File
@@ -204,16 +204,13 @@ namespace API::Subsonic
if (!user)
throw UserNotAuthorizedError{};
const auto trackIds{ Track::find(context.dbSession, Track::FindParameters {}.setSortMethod(TrackSortMethod::Random).setRange({0, size})) };
const auto tracks{ Track::find(context.dbSession, Track::FindParameters {}.setSortMethod(TrackSortMethod::Random).setRange({0, size})) };
Response response{ Response::createOkResponse(context.serverProtocolVersion) };
Response::Node& randomSongsNode{ response.createNode("randomSongs") };
for (const TrackId trackId : trackIds.results)
{
const Track::pointer track{ Track::find(context.dbSession, trackId) };
for (const Track::pointer& track : tracks.results)
randomSongsNode.addArrayChild("song", createSongNode(context, track, user));
}
return response;
}
@@ -250,12 +247,9 @@ namespace API::Subsonic
params.setClusters({ cluster->getId() });
params.setRange({ offset, size });
auto trackIds{ Track::find(context.dbSession, params) };
for (const TrackId trackId : trackIds.results)
{
const Track::pointer track{ Track::find(context.dbSession, trackId) };
const auto tracks{ Track::find(context.dbSession, params) };
for (const Track::pointer& track : tracks.results)
songsByGenreNode.addArrayChild("song", createSongNode(context, track, user));
}
return response;
}
src/libs/subsonic/impl/entrypoints/Browsing.cpp
+4 -10
View File
@@ -194,7 +194,7 @@ namespace API::Subsonic
params.setRange({ 0, meanTrackCountPerArtist });
params.setSortMethod(TrackSortMethod::Random);
const auto artistTracks{ Track::find(context.dbSession, params) };
const auto artistTracks{ Track::findIds(context.dbSession, params) };
tracks.insert(std::end(tracks),
std::begin(artistTracks.results),
std::end(artistTracks.results));
@@ -225,7 +225,7 @@ namespace API::Subsonic
params.setRange({ 0, meanTrackCountPerRelease });
params.setSortMethod(TrackSortMethod::Random);
const auto releaseTracks{ Track::find(context.dbSession, params) };
const auto releaseTracks{ Track::findIds(context.dbSession, params) };
tracks.insert(std::end(tracks),
std::begin(releaseTracks.results),
std::end(releaseTracks.results));
@@ -349,12 +349,9 @@ namespace API::Subsonic
directoryNode.setAttribute("name", Utils::makeNameFilesystemCompatible(release->getName()));
const auto tracks{ Track::find(context.dbSession, Track::FindParameters {}.setRelease(*releaseId).setSortMethod(TrackSortMethod::Release)) };
for (const TrackId trackId : tracks.results)
{
const Track::pointer track{ Track::find(context.dbSession, trackId) };
for (const Track::pointer& track : tracks.results)
directoryNode.addArrayChild("child", createSongNode(context, track, user));
}
}
else
throw BadParameterGenericError{ "id" };
@@ -432,11 +429,8 @@ namespace API::Subsonic
Response::Node albumNode{ createAlbumNode(context, release, user, true /* id3 */) };
const auto tracks{ Track::find(context.dbSession, Track::FindParameters {}.setRelease(id).setSortMethod(TrackSortMethod::Release)) };
for (const TrackId trackId : tracks.results)
{
const Track::pointer track{ Track::find(context.dbSession, trackId) };
for (const Track::pointer& track : tracks.results)
albumNode.addArrayChild("song", createSongNode(context, track, user));
}
response.addNode("album", std::move(albumNode));
src/libs/subsonic/impl/entrypoints/Searching.cpp
+2 -7
View File
@@ -86,8 +86,7 @@ namespace API::Subsonic
params.setKeywords(keywords);
params.setRange({ albumOffset, albumCount });
RangeResults<Release::pointer> releases{ Release::find(context.dbSession, params) };
for (const Release::pointer& release : releases.results)
for (const Release::pointer& release : Release::find(context.dbSession, params).results)
searchResult2Node.addArrayChild("album", createAlbumNode(context, release, user, id3));
}
@@ -97,13 +96,9 @@ namespace API::Subsonic
params.setKeywords(keywords);
params.setRange({ songOffset, songCount });
RangeResults<TrackId> trackIds{ Track::find(context.dbSession, params) };
for (const TrackId trackId : trackIds.results)
{
const auto track{ Track::find(context.dbSession, trackId) };
for (const Track::pointer& track : Track::find(context.dbSession, params).results)
searchResult2Node.addArrayChild("song", createSongNode(context, track, user));
}
}
return response;
}
src/libs/subsonic/impl/responses/Song.cpp
+1
View File
@@ -110,6 +110,7 @@ namespace API::Subsonic
trackResponse.setAttribute("playCount", Listen::getCount(context.dbSession, user->getId(), user->getScrobblingBackend(), track->getId()));
trackResponse.setAttribute("path", getTrackPath(track));
{
// TODO, store this in DB
std::error_code ec;
const auto fileSize{ std::filesystem::file_size(track->getPath(), ec) };
if (!ec)
src/lms/ui/PlayQueue.cpp
+206 -238
View File
@@ -51,14 +51,14 @@
#include "ModalManager.hpp"
#include "Utils.hpp"
namespace UserInterface {
namespace
namespace UserInterface
{
namespace
{
class CreateTrackListModel : public Wt::WFormModel
{
public:
static inline const Field NameField {"name"};
static inline const Field NameField{ "name" };
CreateTrackListModel()
{
@@ -72,7 +72,7 @@ namespace
class ReplaceTrackListModel : public Wt::WFormModel
{
public:
static inline const Field NameField {"name"};
static inline const Field NameField{ "name" };
using TrackListModel = ValueStringModel<Database::TrackListId>;
ReplaceTrackListModel()
@@ -83,7 +83,7 @@ namespace
Database::TrackListId getTrackListId() const
{
auto row {trackListModel->getRowFromString(valueText(NameField))};
auto row{ trackListModel->getRowFromString(valueText(NameField)) };
return trackListModel->getValue(*row);
}
@@ -93,45 +93,45 @@ namespace
{
using namespace Database;
auto model {std::make_shared<TrackListModel>()};
auto model{ std::make_shared<TrackListModel>() };
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
TrackList::FindParameters params;
params.setType(TrackListType::Playlist);
params.setUser(LmsApp->getUserId());
params.setSortMethod(TrackListSortMethod::Name);
auto tracklists {TrackList::find(LmsApp->getDbSession(), params)};
auto tracklists{ TrackList::find(LmsApp->getDbSession(), params) };
for (const TrackListId trackListId : tracklists.results)
{
const TrackList::pointer trackList {TrackList::find(LmsApp->getDbSession(), trackListId)};
model->add(Wt::WString::fromUTF8(std::string {trackList->getName()}), trackListId);
const TrackList::pointer trackList{ TrackList::find(LmsApp->getDbSession(), trackListId) };
model->add(Wt::WString::fromUTF8(std::string{ trackList->getName() }), trackListId);
}
return model;
}
std::shared_ptr<TrackListModel> trackListModel {createTrackListModel()};
std::shared_ptr<TrackListModel> trackListModel{ createTrackListModel() };
};
}
}
PlayQueue::PlayQueue()
: Template {Wt::WString::tr("Lms.PlayQueue.template")}
, _capacity {Service<IConfig>::get()->getULong("playqueue-max-entry-count", 1000)}
{
PlayQueue::PlayQueue()
: Template{ Wt::WString::tr("Lms.PlayQueue.template") }
, _capacity{ Service<IConfig>::get()->getULong("playqueue-max-entry-count", 1000) }
{
initTrackLists();
addFunction("id", &Wt::WTemplate::Functions::id);
addFunction("tr", &Wt::WTemplate::Functions::tr);
Wt::WPushButton* clearBtn {bindNew<Wt::WPushButton>("clear-btn", Wt::WString::tr("Lms.PlayQueue.template.clear-btn"), Wt::TextFormat::XHTML)};
Wt::WPushButton* clearBtn{ bindNew<Wt::WPushButton>("clear-btn", Wt::WString::tr("Lms.PlayQueue.template.clear-btn"), Wt::TextFormat::XHTML) };
clearBtn->clicked().connect([=]
{
clearTracks();
});
Wt::WPushButton* saveBtn {bindNew<Wt::WPushButton>("save-btn", Wt::WString::tr("Lms.PlayQueue.template.save-btn"), Wt::TextFormat::XHTML)};
Wt::WPushButton* saveBtn{ bindNew<Wt::WPushButton>("save-btn", Wt::WString::tr("Lms.PlayQueue.template.save-btn"), Wt::TextFormat::XHTML) };
saveBtn->clicked().connect([=]
{
saveAsTrackList();
@@ -144,14 +144,14 @@ PlayQueue::PlayQueue()
updateCurrentTrack(true);
});
Wt::WPushButton* shuffleBtn {bindNew<Wt::WPushButton>("shuffle-btn", Wt::WString::tr("Lms.PlayQueue.template.shuffle-btn"), Wt::TextFormat::XHTML)};
Wt::WPushButton* shuffleBtn{ bindNew<Wt::WPushButton>("shuffle-btn", Wt::WString::tr("Lms.PlayQueue.template.shuffle-btn"), Wt::TextFormat::XHTML) };
shuffleBtn->clicked().connect([=]
{
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
Database::TrackList::pointer queue {getQueue()};
auto entries {queue->getEntries()};
Database::TrackList::pointer queue{ getQueue() };
auto entries{ queue->getEntries() };
Random::shuffleContainer(entries);
queue.modify()->clear();
@@ -165,13 +165,13 @@ PlayQueue::PlayQueue()
_repeatBtn = bindNew<Wt::WCheckBox>("repeat-btn");
_repeatBtn->clicked().connect([=]
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
if (!LmsApp->getUser()->isDemo())
LmsApp->getUser().modify()->setRepeatAll(isRepeatAllSet());
});
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
if (LmsApp->getUser()->isRepeatAllSet())
_repeatBtn->setCheckState(Wt::CheckState::Checked);
}
@@ -180,7 +180,7 @@ PlayQueue::PlayQueue()
_radioBtn->clicked().connect([=]
{
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
if (!LmsApp->getUser()->isDemo())
LmsApp->getUser().modify()->setRadio(isRadioModeSet());
@@ -189,9 +189,9 @@ PlayQueue::PlayQueue()
enqueueRadioTracksIfNeeded();
});
bool isRadioModeSet {};
bool isRadioModeSet{};
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
isRadioModeSet = LmsApp->getUser()->isRadioSet();
}
if (isRadioModeSet)
@@ -210,10 +210,10 @@ PlayQueue::PlayQueue()
_mediaPlayerSettingsLoaded = true;
std::size_t trackPos {};
std::size_t trackPos{};
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
trackPos = LmsApp->getUser()->getCurPlayingTrackPos();
}
@@ -222,77 +222,70 @@ PlayQueue::PlayQueue()
LmsApp->preQuit().connect([=]
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
if (LmsApp->getUser()->isDemo())
{
LMS_LOG(UI, DEBUG) << "Removing queue (tracklist id " << _queueId.toString() << ")";
if (Database::TrackList::pointer queue {getQueue()})
if (Database::TrackList::pointer queue{ getQueue() })
queue.remove();
}
});
updateInfo();
}
}
bool
PlayQueue::isRepeatAllSet() const
{
return _repeatBtn->checkState() == Wt::CheckState::Checked;
}
bool
PlayQueue::isRadioModeSet() const
{
return _radioBtn->checkState() == Wt::CheckState::Checked;
}
Database::TrackList::pointer
PlayQueue::getQueue() const
{
return Database::TrackList::find(LmsApp->getDbSession(), _queueId);
}
bool
PlayQueue::isFull() const
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
return getQueue()->getCount() == getCapacity();
}
void
PlayQueue::clearTracks()
{
bool PlayQueue::isRepeatAllSet() const
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
return _repeatBtn->checkState() == Wt::CheckState::Checked;
}
bool PlayQueue::isRadioModeSet() const
{
return _radioBtn->checkState() == Wt::CheckState::Checked;
}
Database::TrackList::pointer PlayQueue::getQueue() const
{
return Database::TrackList::find(LmsApp->getDbSession(), _queueId);
}
bool PlayQueue::isFull() const
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
return getQueue()->getCount() == getCapacity();
}
void PlayQueue::clearTracks()
{
{
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
getQueue().modify()->clear();
}
_entriesContainer->reset();
_trackPos.reset();
updateInfo();
}
}
void
PlayQueue::stop()
{
void PlayQueue::stop()
{
updateCurrentTrack(false);
_trackPos.reset();
_isTrackSelected = false;
trackUnselected.emit();
}
}
void
PlayQueue::loadTrack(std::size_t pos, bool play)
{
void PlayQueue::loadTrack(std::size_t pos, bool play)
{
updateCurrentTrack(false);
Database::TrackId trackId {};
std::optional<float> replayGain {};
Database::TrackId trackId{};
std::optional<float> replayGain{};
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const Database::TrackList::pointer queue {getQueue()};
const Database::TrackList::pointer queue{ getQueue() };
// If out of range, stop playing
if (pos >= queue->getCount())
@@ -307,7 +300,7 @@ PlayQueue::loadTrack(std::size_t pos, bool play)
}
_trackPos = pos;
const Database::Track::pointer track {queue->getEntry(*_trackPos)->getTrack()};
const Database::Track::pointer track{ queue->getEntry(*_trackPos)->getTrack() };
trackId = track->getId();
@@ -321,11 +314,10 @@ PlayQueue::loadTrack(std::size_t pos, bool play)
updateCurrentTrack(true);
_isTrackSelected = true;
trackSelected.emit(trackId, play, replayGain ? *replayGain : 0);
}
}
void
PlayQueue::playPrevious()
{
void PlayQueue::playPrevious()
{
if (!_trackPos)
return;
@@ -333,11 +325,10 @@ PlayQueue::playPrevious()
stop();
else
loadTrack(*_trackPos - 1, true);
}
}
void
PlayQueue::playNext()
{
void PlayQueue::playNext()
{
if (!_trackPos)
{
loadTrack(0, true);
@@ -345,86 +336,80 @@ PlayQueue::playNext()
}
loadTrack(*_trackPos + 1, true);
}
}
void
PlayQueue::onPlaybackEnded()
{
void PlayQueue::onPlaybackEnded()
{
playNext();
}
}
std::size_t
PlayQueue::getCount()
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
std::size_t PlayQueue::getCount()
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
return getQueue()->getCount();
}
}
void
PlayQueue::initTrackLists()
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
void PlayQueue::initTrackLists()
{
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
Database::TrackList::pointer queue;
Database::TrackList::pointer radioStartingTracks;
if (!LmsApp->getUser()->isDemo())
{
static const std::string queueName {"__queued_tracks__"};
static const std::string queueName{ "__queued_tracks__" };
queue = Database::TrackList::find(LmsApp->getDbSession(), queueName, Database::TrackListType::Internal, LmsApp->getUserId());
if (!queue)
queue = LmsApp->getDbSession().create<Database::TrackList>(queueName, Database::TrackListType::Internal, false, LmsApp->getUser());
}
else
{
static const std::string queueName {"__temp_queue__"};
static const std::string queueName{ "__temp_queue__" };
queue = LmsApp->getDbSession().create<Database::TrackList>(queueName, Database::TrackListType::Internal, false, LmsApp->getUser());
}
_queueId = queue->getId();
}
}
void
PlayQueue::updateInfo()
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
void PlayQueue::updateInfo()
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const Database::TrackList::pointer queue {getQueue()};
const std::size_t trackCount {queue->getCount()};
const Database::TrackList::pointer queue{ getQueue() };
const std::size_t trackCount{ queue->getCount() };
_nbTracks->setText(Wt::WString::trn("Lms.track-count", trackCount).arg(trackCount));
_duration->setText(Utils::durationToString(queue->getDuration()));
trackCountChanged.emit(trackCount);
}
}
void
PlayQueue::updateCurrentTrack(bool selected)
{
void PlayQueue::updateCurrentTrack(bool selected)
{
if (!_trackPos || *_trackPos >= static_cast<std::size_t>(_entriesContainer->getCount()))
return;
Template* entry {static_cast<Template*>(_entriesContainer->getWidget(*_trackPos))};
Template* entry{ static_cast<Template*>(_entriesContainer->getWidget(*_trackPos)) };
if (!entry)
return;
entry->toggleStyleClass("Lms-entry-playing", selected);
}
}
void
PlayQueue::enqueueTracks(const std::vector<Database::TrackId>& trackIds)
{
void PlayQueue::enqueueTracks(const std::vector<Database::TrackId>& trackIds)
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
{
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
Database::TrackList::pointer queue {getQueue()};
const std::size_t queueSize {queue->getCount()};
Database::TrackList::pointer queue{ getQueue() };
const std::size_t queueSize{ queue->getCount() };
std::size_t nbTracksToEnqueue {queueSize + trackIds.size() > getCapacity() ? getCapacity() - queueSize : trackIds.size()};
std::size_t nbTracksToEnqueue{ queueSize + trackIds.size() > getCapacity() ? getCapacity() - queueSize : trackIds.size() };
for (const Database::TrackId trackId : trackIds)
{
if (nbTracksToEnqueue == 0)
break;
Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), trackId)};
Database::Track::pointer track{ Database::Track::find(LmsApp->getDbSession(), trackId) };
if (!track)
continue;
@@ -436,17 +421,16 @@ PlayQueue::enqueueTracks(const std::vector<Database::TrackId>& trackIds)
updateInfo();
addSome();
_entriesContainer->setHasMore();
}
}
std::vector<Database::TrackId>
PlayQueue::getAndClearNextTracks()
{
std::vector<Database::TrackId> PlayQueue::getAndClearNextTracks()
{
std::vector<Database::TrackId> tracks;
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
Database::TrackList::pointer queue {getQueue()};
std::vector<Database::TrackListEntry::pointer> entries {queue->getEntries(Database::Range {_trackPos ? *_trackPos + 1 : 0, getCapacity()})};
Database::TrackList::pointer queue{ getQueue() };
std::vector<Database::TrackListEntry::pointer> entries{ queue->getEntries(Database::Range {_trackPos ? *_trackPos + 1 : 0, getCapacity()}) };
tracks.reserve(entries.size());
for (Database::TrackListEntry::pointer entry : entries)
{
@@ -466,72 +450,65 @@ PlayQueue::getAndClearNextTracks()
}
return tracks;
}
}
void
PlayQueue::play(const std::vector<Database::TrackId>& trackIds)
{
void PlayQueue::play(const std::vector<Database::TrackId>& trackIds)
{
playAtIndex(trackIds, 0);
}
}
void
PlayQueue::playNext(const std::vector<Database::TrackId>& trackIds)
{
std::vector<Database::TrackId> nextTracks {getAndClearNextTracks()};
void PlayQueue::playNext(const std::vector<Database::TrackId>& trackIds)
{
std::vector<Database::TrackId> nextTracks{ getAndClearNextTracks() };
nextTracks.insert(std::cbegin(nextTracks), std::cbegin(trackIds), std::cend(trackIds));
playOrAddLast(nextTracks);
}
}
void
PlayQueue::playShuffled(const std::vector<Database::TrackId>& trackIds)
{
void PlayQueue::playShuffled(const std::vector<Database::TrackId>& trackIds)
{
clearTracks();
std::vector<Database::TrackId> shuffledTrackIds {trackIds};
std::vector<Database::TrackId> shuffledTrackIds{ trackIds };
Random::shuffleContainer(shuffledTrackIds);
enqueueTracks(shuffledTrackIds);
loadTrack(0, true);
}
}
void
PlayQueue::playOrAddLast(const std::vector<Database::TrackId>& trackIds)
{
void PlayQueue::playOrAddLast(const std::vector<Database::TrackId>& trackIds)
{
enqueueTracks(trackIds);
if (!_isTrackSelected)
loadTrack(0, true);
}
}
void
PlayQueue::playAtIndex(const std::vector<Database::TrackId>& trackIds, std::size_t index)
{
void PlayQueue::playAtIndex(const std::vector<Database::TrackId>& trackIds, std::size_t index)
{
clearTracks();
enqueueTracks(trackIds);
loadTrack(index, true);
}
}
void
PlayQueue::addSome()
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
void PlayQueue::addSome()
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const Database::TrackList::pointer queue {getQueue()};
const auto tracklistEntries {queue->getEntries(Database::Range {_entriesContainer->getCount(), _batchSize})};
const Database::TrackList::pointer queue{ getQueue() };
const auto tracklistEntries{ queue->getEntries(Database::Range {_entriesContainer->getCount(), _batchSize}) };
for (const Database::TrackListEntry::pointer& tracklistEntry : tracklistEntries)
addEntry(tracklistEntry);
}
}
void
PlayQueue::addEntry(const Database::TrackListEntry::pointer& tracklistEntry)
{
const Database::TrackListEntryId tracklistEntryId {tracklistEntry->getId()};
const auto track {tracklistEntry->getTrack()};
const Database::TrackId trackId {track->getId()};
void PlayQueue::addEntry(const Database::TrackListEntry::pointer& tracklistEntry)
{
const Database::TrackListEntryId tracklistEntryId{ tracklistEntry->getId() };
const auto track{ tracklistEntry->getTrack() };
const Database::TrackId trackId{ track->getId() };
Template* entry {_entriesContainer->addNew<Template>(Wt::WString::tr("Lms.PlayQueue.template.entry"))};
Template* entry{ _entriesContainer->addNew<Template>(Wt::WString::tr("Lms.PlayQueue.template.entry")) };
entry->addFunction("id", &Wt::WTemplate::Functions::id);
entry->bindString("name", Wt::WString::fromUTF8(track->getName()), Wt::TextFormat::Plain);
const auto artists {track->getArtistIds({Database::TrackArtistLinkType::Artist})};
const auto artists{ track->getArtistIds({Database::TrackArtistLinkType::Artist}) };
if (!artists.empty())
{
entry->setCondition("if-has-artists", true);
@@ -539,49 +516,49 @@ PlayQueue::addEntry(const Database::TrackListEntry::pointer& tracklistEntry)
entry->bindWidget("artists-md", Utils::createArtistAnchorList(artists));
}
const auto release {track->getRelease()};
const auto release{ track->getRelease() };
if (release)
{
entry->setCondition("if-has-release", true);
entry->bindWidget("release", Utils::createReleaseAnchor(release));
{
Wt::WAnchor* anchor {entry->bindWidget("cover", Utils::createReleaseAnchor(release, false))};
auto cover {Utils::createCover(release->getId(), CoverResource::Size::Small)};
Wt::WAnchor* anchor{ entry->bindWidget("cover", Utils::createReleaseAnchor(release, false)) };
auto cover{ Utils::createCover(release->getId(), CoverResource::Size::Small) };
cover->addStyleClass("Lms-cover-track Lms-cover-anchor"); // HACK
anchor->setImage(std::move(cover));
}
}
else
{
auto cover {entry->bindWidget<Wt::WImage>("cover", Utils::createCover(track->getId(), CoverResource::Size::Small))};
auto cover{ entry->bindWidget<Wt::WImage>("cover", Utils::createCover(track->getId(), CoverResource::Size::Small)) };
cover->addStyleClass("Lms-cover-track");
}
entry->bindString("duration", Utils::durationToString(track->getDuration()), Wt::TextFormat::Plain);
Wt::WPushButton* playBtn {entry->bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.template.play-btn"), Wt::TextFormat::XHTML)};
Wt::WPushButton* playBtn{ entry->bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.template.play-btn"), Wt::TextFormat::XHTML) };
playBtn->clicked().connect([=]
{
const std::optional<std::size_t> pos {_entriesContainer->getIndexOf(*entry)};
const std::optional<std::size_t> pos{ _entriesContainer->getIndexOf(*entry) };
if (pos)
loadTrack(*pos, true);
});
Wt::WPushButton* delBtn {entry->bindNew<Wt::WPushButton>("del-btn", Wt::WString::tr("Lms.template.delete-btn"), Wt::TextFormat::XHTML)};
Wt::WPushButton* delBtn{ entry->bindNew<Wt::WPushButton>("del-btn", Wt::WString::tr("Lms.template.delete-btn"), Wt::TextFormat::XHTML) };
delBtn->setToolTip(Wt::WString::tr("Lms.delete"));
delBtn->clicked().connect([=]
{
// Remove the entry n both the widget tree and the playqueue
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
Database::TrackListEntry::pointer entryToRemove {Database::TrackListEntry::getById(LmsApp->getDbSession(), tracklistEntryId)};
Database::TrackListEntry::pointer entryToRemove{ Database::TrackListEntry::getById(LmsApp->getDbSession(), tracklistEntryId) };
entryToRemove.remove();
}
if (_trackPos)
{
const std::optional<std::size_t> pos {_entriesContainer->getIndexOf(*entry)};
const std::optional<std::size_t> pos{ _entriesContainer->getIndexOf(*entry) };
if (pos && *_trackPos >= *pos)
(*_trackPos)--;
else if (*_trackPos >= _entriesContainer->getCount())
@@ -597,17 +574,17 @@ PlayQueue::addEntry(const Database::TrackListEntry::pointer& tracklistEntry)
entry->bindNew<Wt::WPushButton>("play", Wt::WString::tr("Lms.Explore.play"))
->clicked().connect([=]
{
const std::optional<std::size_t> pos {_entriesContainer->getIndexOf(*entry)};
const std::optional<std::size_t> pos{ _entriesContainer->getIndexOf(*entry) };
if (pos)
loadTrack(*pos, true);
});
auto isStarred {[=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), trackId); }};
auto isStarred{ [=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), trackId); } };
Wt::WPushButton* starBtn {entry->bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star"))};
Wt::WPushButton* starBtn{ entry->bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star")) };
starBtn->clicked().connect([=]
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
if (isStarred())
{
@@ -622,20 +599,19 @@ PlayQueue::addEntry(const Database::TrackListEntry::pointer& tracklistEntry)
});
entry->bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
->setLink(Wt::WLink {std::make_unique<DownloadTrackResource>(trackId)});
}
->setLink(Wt::WLink{ std::make_unique<DownloadTrackResource>(trackId) });
}
void
PlayQueue::enqueueRadioTracksIfNeeded()
{
void PlayQueue::enqueueRadioTracksIfNeeded()
{
if (!isRadioModeSet())
return;
bool addTracks {};
bool addTracks{};
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const Database::TrackList::pointer queue {getQueue()};
const Database::TrackList::pointer queue{ getQueue() };
// If out of range, stop playing
if (_trackPos >= queue->getCount() - 1)
@@ -644,19 +620,17 @@ PlayQueue::enqueueRadioTracksIfNeeded()
if (addTracks)
enqueueRadioTracks();
}
}
void
PlayQueue::enqueueRadioTracks()
{
void PlayQueue::enqueueRadioTracks()
{
std::vector<Database::TrackId> trackIds = Service<Recommendation::IPlaylistGeneratorService>::get()->extendPlaylist(_queueId, 15);
enqueueTracks(trackIds);
}
}
std::optional<float>
PlayQueue::getReplayGain(std::size_t pos, const Database::Track::pointer& track) const
{
const auto& settings {LmsApp->getMediaPlayer().getSettings()};
std::optional<float> PlayQueue::getReplayGain(std::size_t pos, const Database::Track::pointer& track) const
{
const auto& settings{ LmsApp->getMediaPlayer().getSettings() };
if (!settings)
return std::nullopt;
@@ -679,11 +653,11 @@ PlayQueue::getReplayGain(std::size_t pos, const Database::Track::pointer& track)
case MediaPlayer::Settings::ReplayGain::Mode::Auto:
{
const Database::TrackList::pointer queue {getQueue()};
const Database::TrackListEntry::pointer prevEntry {pos > 0 ? queue->getEntry(pos - 1) : Database::TrackListEntry::pointer {}};
const Database::TrackListEntry::pointer nextEntry {queue->getEntry(pos + 1)};
const Database::Track::pointer prevTrack {prevEntry ? prevEntry->getTrack() : Database::Track::pointer {}};
const Database::Track::pointer nextTrack {nextEntry ? nextEntry->getTrack() : Database::Track::pointer {}};
const Database::TrackList::pointer queue{ getQueue() };
const Database::TrackListEntry::pointer prevEntry{ pos > 0 ? queue->getEntry(pos - 1) : Database::TrackListEntry::pointer {} };
const Database::TrackListEntry::pointer nextEntry{ queue->getEntry(pos + 1) };
const Database::Track::pointer prevTrack{ prevEntry ? prevEntry->getTrack() : Database::Track::pointer {} };
const Database::Track::pointer nextTrack{ nextEntry ? nextEntry->getTrack() : Database::Track::pointer {} };
if ((prevTrack && prevTrack->getRelease() && prevTrack->getRelease() == track->getRelease())
||
@@ -705,23 +679,22 @@ PlayQueue::getReplayGain(std::size_t pos, const Database::Track::pointer& track)
return *gain + settings->replayGain.preAmpGain;
return settings->replayGain.preAmpGainIfNoInfo;
}
}
void
PlayQueue::saveAsTrackList()
{
auto modal {std::make_unique<Template>(Wt::WString::tr("Lms.PlayQueue.template.save-as-tracklist"))};
void PlayQueue::saveAsTrackList()
{
auto modal{ std::make_unique<Template>(Wt::WString::tr("Lms.PlayQueue.template.save-as-tracklist")) };
modal->addFunction("id", &Wt::WTemplate::Functions::id);
modal->addFunction("tr", &Wt::WTemplate::Functions::tr);
Wt::WWidget* modalPtr {modal.get()};
Wt::WWidget* modalPtr{ modal.get() };
auto* cancelBtn {modal->bindNew<Wt::WPushButton>("cancel-btn", Wt::WString::tr("Lms.cancel"))};
auto* cancelBtn{ modal->bindNew<Wt::WPushButton>("cancel-btn", Wt::WString::tr("Lms.cancel")) };
cancelBtn->clicked().connect([=]
{
LmsApp->getModalManager().dispose(modalPtr);
});
Wt::WStackedWidget* contentStack {modal->bindNew<Wt::WStackedWidget>("contents")};
Wt::WStackedWidget* contentStack{ modal->bindNew<Wt::WStackedWidget>("contents") };
// Create/Replace selector
enum Index : int
@@ -736,7 +709,7 @@ PlayQueue::saveAsTrackList()
contentStack->setCurrentIndex(Index::ReplaceTrackList);
});
Wt::WRadioButton* createTrackListBtn {modal->bindNew<Wt::WRadioButton>("create-tracklist-btn")};
Wt::WRadioButton* createTrackListBtn{ modal->bindNew<Wt::WRadioButton>("create-tracklist-btn") };
createTrackListBtn->setChecked();
createTrackListBtn->clicked().connect([=]
{
@@ -746,25 +719,25 @@ PlayQueue::saveAsTrackList()
// Create TrackList
Wt::WTemplateFormView* createTrackList {contentStack->addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.PlayQueue.template.save-as-tracklist.create-tracklist"))};
auto createTrackListModel {std::make_shared<CreateTrackListModel>()};
Wt::WTemplateFormView* createTrackList{ contentStack->addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.PlayQueue.template.save-as-tracklist.create-tracklist")) };
auto createTrackListModel{ std::make_shared<CreateTrackListModel>() };
createTrackList->setFormWidget(CreateTrackListModel::NameField, std::make_unique<Wt::WLineEdit>());
createTrackList->updateView(createTrackListModel.get());
// Replace TrackList
Wt::WTemplateFormView* replaceTrackList {contentStack->addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.PlayQueue.template.save-as-tracklist.replace-tracklist"))};
auto replaceTrackListModel {std::make_shared<ReplaceTrackListModel>()};
Wt::WTemplateFormView* replaceTrackList{ contentStack->addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.PlayQueue.template.save-as-tracklist.replace-tracklist")) };
auto replaceTrackListModel{ std::make_shared<ReplaceTrackListModel>() };
{
auto name {std::make_unique<Wt::WComboBox>()};
auto name{ std::make_unique<Wt::WComboBox>() };
name->setModel(replaceTrackListModel->trackListModel);
replaceTrackList->setFormWidget(ReplaceTrackListModel::NameField, std::move(name));
}
replaceTrackList->updateView(replaceTrackListModel.get());
auto* saveBtn {modal->bindNew<Wt::WPushButton>("save-btn", Wt::WString::tr("Lms.save"))};
auto* saveBtn{ modal->bindNew<Wt::WPushButton>("save-btn", Wt::WString::tr("Lms.save")) };
saveBtn->clicked().connect([=]
{
bool success {};
bool success{};
switch (contentStack->currentIndex())
{
case Index::CreateTrackList:
@@ -793,34 +766,32 @@ PlayQueue::saveAsTrackList()
});
LmsApp->getModalManager().show(std::move(modal));
}
}
void
PlayQueue::exportToNewTrackList(const Wt::WString& name)
{
void PlayQueue::exportToNewTrackList(const Wt::WString& name)
{
using namespace Database;
Database::TrackListId trackListId;
{
Session& session {LmsApp->getDbSession()};
auto transaction {session.createUniqueTransaction()};
TrackList::pointer trackList {session.create<TrackList>(name.toUTF8(), TrackListType::Playlist, false, LmsApp->getUser())};
Session& session{ LmsApp->getDbSession() };
auto transaction{ session.createUniqueTransaction() };
TrackList::pointer trackList{ session.create<TrackList>(name.toUTF8(), TrackListType::Playlist, false, LmsApp->getUser()) };
trackListId = trackList->getId();
}
exportToTrackList(trackListId);
}
}
void
PlayQueue::exportToTrackList(Database::TrackListId trackListId)
{
void PlayQueue::exportToTrackList(Database::TrackListId trackListId)
{
using namespace Database;
Session& session {LmsApp->getDbSession()};
auto transaction {session.createUniqueTransaction()};
Session& session{ LmsApp->getDbSession() };
auto transaction{ session.createUniqueTransaction() };
TrackList::pointer trackList {TrackList::find(LmsApp->getDbSession(), trackListId)};
TrackList::pointer trackList{ TrackList::find(LmsApp->getDbSession(), trackListId) };
trackList.modify()->clear();
Track::FindParameters params;
@@ -828,11 +799,8 @@ PlayQueue::exportToTrackList(Database::TrackListId trackListId)
params.setDistinct(false);
params.setSortMethod(TrackSortMethod::TrackList);
const auto tracks {Track::find(session, params)};
for (const TrackId trackId : tracks.results)
session.create<TrackListEntry>(Track::find(session, trackId), trackList);
}
const auto tracks{ Track::find(session, params) };
for (const Track::pointer& track : tracks.results)
session.create<TrackListEntry>(track, trackList);
}
} // namespace UserInterface
src/lms/ui/explore/ArtistView.cpp
+2 -2
View File
@@ -369,12 +369,12 @@ Artist::addSomeNonReleaseTracks()
params.setNonRelease(true);
const auto tracks {Track::find(LmsApp->getDbSession(), params)};
for (const TrackId trackId : tracks.results)
for (const Track::pointer& track : tracks.results)
{
// TODO handle this with range
if (_trackContainer->getCount() == _tracksMaxCount)
break;
const Track::pointer track {Track::find(LmsApp->getDbSession(), trackId)};
_trackContainer->add(TrackListHelpers::createEntry(track, _playQueueController, _filters));
areTracksAdded = true;
src/lms/ui/explore/PlayQueueController.cpp
+30 -38
View File
@@ -29,15 +29,15 @@
namespace UserInterface
{
static
std::vector<Database::TrackId>
getArtistsTracks(Database::Session& session, const std::vector<Database::ArtistId>& artistsId, const std::vector<Database::ClusterId>& clusters, std::size_t maxTrackCount)
namespace
{
std::vector<Database::TrackId> getArtistsTracks(Database::Session& session, const std::vector<Database::ArtistId>& artistsId, const std::vector<Database::ClusterId>& clusters, std::size_t maxTrackCount)
{
assert(maxTrackCount);
std::vector<Database::TrackId> res;
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
for (const Database::ArtistId artistId : artistsId)
{
@@ -45,9 +45,9 @@ namespace UserInterface
params.setArtist(artistId);
params.setSortMethod(Database::TrackSortMethod::DateDescAndRelease);
params.setClusters(clusters);
params.setRange({0, maxTrackCount - res.size()});
params.setRange({ 0, maxTrackCount - res.size() });
const auto tracks {Database::Track::find(session, params)};
const auto tracks{ Database::Track::findIds(session, params) };
res.reserve(res.size() + tracks.results.size());
res.insert(std::end(res), std::cbegin(tracks.results), std::cend(tracks.results));
@@ -59,16 +59,14 @@ namespace UserInterface
return res;
}
static
std::vector<Database::TrackId>
getReleasesTracks(Database::Session& session, const std::vector<Database::ReleaseId>& releasesId, const std::vector<Database::ClusterId>& clusters, std::size_t maxTrackCount)
std::vector<Database::TrackId> getReleasesTracks(Database::Session& session, const std::vector<Database::ReleaseId>& releasesId, const std::vector<Database::ClusterId>& clusters, std::size_t maxTrackCount)
{
using namespace Database;
assert(maxTrackCount);
std::vector<TrackId> res;
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
for (const ReleaseId releaseId : releasesId)
{
@@ -76,9 +74,9 @@ namespace UserInterface
params.setRelease(releaseId);
params.setSortMethod(Database::TrackSortMethod::Release);
params.setClusters(clusters);
params.setRange({0, maxTrackCount - res.size()});
params.setRange({ 0, maxTrackCount - res.size() });
const auto tracks {Database::Track::find(session, params)};
const auto tracks{ Database::Track::findIds(session, params) };
res.reserve(res.size() + tracks.results.size());
res.insert(std::end(res), std::cbegin(tracks.results), std::cend(tracks.results));
@@ -90,47 +88,43 @@ namespace UserInterface
return res;
}
static
std::vector<Database::TrackId>
getTrackListTracks(Database::Session& session, Database::TrackListId trackListId, const std::vector<Database::ClusterId>& clusters, std::size_t maxTrackCount)
std::vector<Database::TrackId> getTrackListTracks(Database::Session& session, Database::TrackListId trackListId, const std::vector<Database::ClusterId>& clusters, std::size_t maxTrackCount)
{
using namespace Database;
assert(maxTrackCount);
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
Database::Track::FindParameters params;
params.setTrackList(trackListId);
params.setClusters(clusters);
params.setRange({0, maxTrackCount});
params.setRange({ 0, maxTrackCount });
params.setSortMethod(TrackSortMethod::TrackList);
params.setDistinct(false);
return Database::Track::find(session, params).results;
return Database::Track::findIds(session, params).results;
}
}
PlayQueueController::PlayQueueController(Filters& filters, PlayQueue& playQueue)
: _filters {filters}
, _playQueue {playQueue}
: _filters{ filters }
, _playQueue{ playQueue }
{
}
void
PlayQueueController::processCommand(Command command, const std::vector<Database::ArtistId>& artistIds)
void PlayQueueController::processCommand(Command command, const std::vector<Database::ArtistId>& artistIds)
{
const std::vector<Database::TrackId> tracks {getArtistsTracks(LmsApp->getDbSession(), artistIds, _filters.getClusterIds(), _maxTrackCountToEnqueue)};
const std::vector<Database::TrackId> tracks{ getArtistsTracks(LmsApp->getDbSession(), artistIds, _filters.getClusterIds(), _maxTrackCountToEnqueue) };
processCommand(command, tracks);
}
void
PlayQueueController::processCommand(Command command, const std::vector<Database::ReleaseId>& releaseIds)
void PlayQueueController::processCommand(Command command, const std::vector<Database::ReleaseId>& releaseIds)
{
const std::vector<Database::TrackId> tracks {getReleasesTracks(LmsApp->getDbSession(), releaseIds, _filters.getClusterIds(), _maxTrackCountToEnqueue)};
const std::vector<Database::TrackId> tracks{ getReleasesTracks(LmsApp->getDbSession(), releaseIds, _filters.getClusterIds(), _maxTrackCountToEnqueue) };
processCommand(command, tracks);
}
void
PlayQueueController::processCommand(Command command, const std::vector<Database::TrackId>& trackIds)
void PlayQueueController::processCommand(Command command, const std::vector<Database::TrackId>& trackIds)
{
// consider things are already filtered here, and _maxTrackCount honored playqueue side...
switch (command)
@@ -150,32 +144,30 @@ namespace UserInterface
}
}
void
PlayQueueController::processCommand(Command command, Database::TrackListId trackListId)
void PlayQueueController::processCommand(Command command, Database::TrackListId trackListId)
{
const std::vector<Database::TrackId> tracks {getTrackListTracks(LmsApp->getDbSession(), trackListId, _filters.getClusterIds(), _maxTrackCountToEnqueue)};
const std::vector<Database::TrackId> tracks{ getTrackListTracks(LmsApp->getDbSession(), trackListId, _filters.getClusterIds(), _maxTrackCountToEnqueue) };
processCommand(command, tracks);
}
void
PlayQueueController::playTrackInRelease(Database::TrackId trackId)
void PlayQueueController::playTrackInRelease(Database::TrackId trackId)
{
Database::ReleaseId releaseId;
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
const Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), trackId)};
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const Database::Track::pointer track{ Database::Track::find(LmsApp->getDbSession(), trackId) };
if (!track || !track->getRelease())
return;
releaseId = track->getRelease()->getId();
}
const std::vector<Database::TrackId> tracks {getReleasesTracks(LmsApp->getDbSession(), {releaseId}, _filters.getClusterIds(), _maxTrackCountToEnqueue)};
auto itTrack {std::find(std::cbegin(tracks), std::cend(tracks), trackId)};
const std::vector<Database::TrackId> tracks{ getReleasesTracks(LmsApp->getDbSession(), {releaseId}, _filters.getClusterIds(), _maxTrackCountToEnqueue) };
auto itTrack{ std::find(std::cbegin(tracks), std::cend(tracks), trackId) };
if (itTrack == std::cend(tracks))
return;
const std::size_t index {static_cast<std::size_t>(std::distance(std::cbegin(tracks), itTrack))};
const std::size_t index{ static_cast<std::size_t>(std::distance(std::cbegin(tracks), itTrack)) };
_playQueue.playAtIndex(tracks, index);
}
} // namespace UserInterface
src/lms/ui/explore/ReleaseView.cpp
+116 -129
View File
@@ -50,22 +50,23 @@
using namespace Database;
namespace UserInterface {
void
showReleaseInfoModal(Database::ReleaseId releaseId)
namespace UserInterface
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
namespace
{
void showReleaseInfoModal(Database::ReleaseId releaseId)
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), releaseId)};
const Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), releaseId) };
if (!release)
return;
auto releaseInfo {std::make_unique<Template>(Wt::WString::tr("Lms.Explore.Release.template.release-info"))};
Wt::WWidget* releaseInfoPtr {releaseInfo.get()};
auto releaseInfo{ std::make_unique<Template>(Wt::WString::tr("Lms.Explore.Release.template.release-info")) };
Wt::WWidget* releaseInfoPtr{ releaseInfo.get() };
releaseInfo->addFunction("tr", &Wt::WTemplate::Functions::tr);
if (auto primaryReleaseType {release->getPrimaryType()})
if (auto primaryReleaseType{ release->getPrimaryType() })
{
releaseInfo->setCondition("if-has-release-type", true);
releaseInfo->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(*primaryReleaseType, release->getSecondaryTypes()));
@@ -78,11 +79,11 @@ showReleaseInfoModal(Database::ReleaseId releaseId)
Artist::FindParameters params;
params.setRelease(releaseId);
params.setLinkType(linkType);
const auto artistIds {Artist::find(LmsApp->getDbSession(), params)};
const auto artistIds{ Artist::find(LmsApp->getDbSession(), params) };
if (artistIds.results.empty())
return;
Wt::WString typeStr {Wt::WString::trn(type, artistIds.results.size())};
Wt::WString typeStr{ Wt::WString::trn(type, artistIds.results.size()) };
for (ArtistId artistId : artistIds.results)
artistMap[typeStr].insert(artistId);
};
@@ -92,17 +93,17 @@ showReleaseInfoModal(Database::ReleaseId releaseId)
TrackArtistLink::FindParameters params;
params.setRelease(releaseId);
params.setLinkType(TrackArtistLinkType::Performer);
const auto links {TrackArtistLink::find(LmsApp->getDbSession(), params)};
const auto links{ TrackArtistLink::find(LmsApp->getDbSession(), params) };
if (links.results.empty())
return;
for (const TrackArtistLinkId linkId : links.results)
{
const TrackArtistLink::pointer link {TrackArtistLink::find(LmsApp->getDbSession(), linkId)};
const TrackArtistLink::pointer link{ TrackArtistLink::find(LmsApp->getDbSession(), linkId) };
if (!link)
continue;
artistMap[std::string {link->getSubType()}].insert(link->getArtist()->getId());
artistMap[std::string{ link->getSubType() }].insert(link->getArtist()->getId());
}
};
@@ -114,9 +115,9 @@ showReleaseInfoModal(Database::ReleaseId releaseId)
addArtists(TrackArtistLinkType::Producer, "Lms.Explore.Artists.linktype-producer");
addPerformerArtists();
if (auto itRolelessPerformers {artistMap.find("")}; itRolelessPerformers != std::cend(artistMap))
if (auto itRolelessPerformers{ artistMap.find("") }; itRolelessPerformers != std::cend(artistMap))
{
Wt::WString performersStr {Wt::WString::trn("Lms.Explore.Artists.linktype-performer", itRolelessPerformers->second.size())};
Wt::WString performersStr{ Wt::WString::trn("Lms.Explore.Artists.linktype-performer", itRolelessPerformers->second.size()) };
artistMap[performersStr] = std::move(itRolelessPerformers->second);
artistMap.erase(itRolelessPerformers);
}
@@ -124,12 +125,12 @@ showReleaseInfoModal(Database::ReleaseId releaseId)
if (!artistMap.empty())
{
releaseInfo->setCondition("if-has-artist", true);
Wt::WContainerWidget* artistTable {releaseInfo->bindNew<Wt::WContainerWidget>("artist-table")};
Wt::WContainerWidget* artistTable{ releaseInfo->bindNew<Wt::WContainerWidget>("artist-table") };
for (const auto& [role, artistIds] : artistMap)
{
std::unique_ptr<Wt::WContainerWidget> artistContainer {Utils::createArtistAnchorList(std::vector (std::cbegin(artistIds), std::cend(artistIds)))};
auto artistsEntry {std::make_unique<Template>(Wt::WString::tr("Lms.Explore.template.info.artists"))};
std::unique_ptr<Wt::WContainerWidget> artistContainer{ Utils::createArtistAnchorList(std::vector(std::cbegin(artistIds), std::cend(artistIds))) };
auto artistsEntry{ std::make_unique<Template>(Wt::WString::tr("Lms.Explore.template.info.artists")) };
artistsEntry->bindString("type", role);
artistsEntry->bindWidget("artist-container", std::move(artistContainer));
artistTable->addWidget(std::move(artistsEntry));
@@ -137,15 +138,11 @@ showReleaseInfoModal(Database::ReleaseId releaseId)
}
// TODO: save in DB and mean all this
for (TrackId trackId : Track::find(LmsApp->getDbSession(), Track::FindParameters {}.setRelease(releaseId).setRange(Range {0, 1})).results)
for (const Track::pointer& track : Track::find(LmsApp->getDbSession(), Track::FindParameters{}.setRelease(releaseId).setRange(Range{ 0, 1 })).results)
{
const Track::pointer track {Track::find(LmsApp->getDbSession(), trackId)};
if (!track)
continue;
if (const auto audioFile {Av::parseAudioFile(track->getPath())})
if (const auto audioFile{ Av::parseAudioFile(track->getPath()) })
{
const std::optional<Av::StreamInfo> audioStream {audioFile->getBestStreamInfo()};
const std::optional<Av::StreamInfo> audioStream{ audioFile->getBestStreamInfo() };
if (audioStream)
{
releaseInfo->setCondition("if-has-codec", true);
@@ -160,20 +157,39 @@ showReleaseInfoModal(Database::ReleaseId releaseId)
}
}
Wt::WPushButton* okBtn {releaseInfo->bindNew<Wt::WPushButton>("ok-btn", Wt::WString::tr("Lms.ok"))};
Wt::WPushButton* okBtn{ releaseInfo->bindNew<Wt::WPushButton>("ok-btn", Wt::WString::tr("Lms.ok")) };
okBtn->clicked().connect([=]
{
LmsApp->getModalManager().dispose(releaseInfoPtr);
});
LmsApp->getModalManager().show(std::move(releaseInfo));
}
}
Release::Release(Filters& filters, PlayQueueController& playQueueController)
: Template {Wt::WString::tr("Lms.Explore.Release.template")}
, _filters {filters}
, _playQueueController {playQueueController}
{
std::optional<ReleaseId> extractReleaseIdFromInternalPath()
{
if (wApp->internalPathMatches("/release/mbid/"))
{
const auto mbid{ UUID::fromString(wApp->internalPathNextPart("/release/mbid/")) };
if (mbid)
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
if (const Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), *mbid) })
return release->getId();
}
return std::nullopt;
}
return StringUtils::readAs<ReleaseId::ValueType>(wApp->internalPathNextPart("/release/"));
}
}
Release::Release(Filters& filters, PlayQueueController& playQueueController)
: Template{ Wt::WString::tr("Lms.Explore.Release.template") }
, _filters{ filters }
, _playQueueController{ playQueueController }
{
addFunction("tr", &Wt::WTemplate::Functions::tr);
addFunction("id", &Wt::WTemplate::Functions::id);
@@ -189,36 +205,14 @@ Release::Release(Filters& filters, PlayQueueController& playQueueController)
});
refreshView();
}
static
std::optional<ReleaseId>
extractReleaseIdFromInternalPath()
{
if (wApp->internalPathMatches("/release/mbid/"))
{
const auto mbid {UUID::fromString(wApp->internalPathNextPart("/release/mbid/"))};
if (mbid)
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
if (const Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), *mbid)})
return release->getId();
}
return std::nullopt;
}
return StringUtils::readAs<ReleaseId::ValueType>(wApp->internalPathNextPart("/release/"));
}
void
Release::refreshView()
{
void Release::refreshView()
{
if (!wApp->internalPathMatches("/release/"))
return;
const auto releaseId {extractReleaseIdFromInternalPath()};
const auto releaseId{ extractReleaseIdFromInternalPath() };
// consider everything is up to date is the same release is being rendered
if (!_needForceRefresh && releaseId && *releaseId == _releaseId)
@@ -229,15 +223,15 @@ Release::refreshView()
_needForceRefresh = false;
if (!releaseId)
throw ReleaseNotFoundException {};
throw ReleaseNotFoundException{};
auto similarReleasesIds {Service<Recommendation::IRecommendationService>::get()->getSimilarReleases(*releaseId, 6)};
auto similarReleasesIds{ Service<Recommendation::IRecommendationService>::get()->getSimilarReleases(*releaseId, 6) };
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), *releaseId)};
const Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), *releaseId) };
if (!release)
throw ReleaseNotFoundException {};
throw ReleaseNotFoundException{};
LmsApp->setTitle(release->getName());
_releaseId = *releaseId;
@@ -248,7 +242,7 @@ Release::refreshView()
bindString("name", Wt::WString::fromUTF8(release->getName()), Wt::TextFormat::Plain);
Wt::WString year {ReleaseHelpers::buildReleaseYearString(release->getReleaseDate(), release->getOriginalReleaseDate())};
Wt::WString year{ ReleaseHelpers::buildReleaseYearString(release->getReleaseDate(), release->getOriginalReleaseDate()) };
if (!year.empty())
{
setCondition("if-has-year", true);
@@ -261,17 +255,17 @@ Release::refreshView()
bindWidget<Wt::WImage>("cover", Utils::createCover(release->getId(), CoverResource::Size::Large));
Wt::WContainerWidget* clusterContainers {bindNew<Wt::WContainerWidget>("clusters")};
Wt::WContainerWidget* clusterContainers{ bindNew<Wt::WContainerWidget>("clusters") };
{
const auto clusterTypes {ScanSettings::get(LmsApp->getDbSession())->getClusterTypes()};
const auto clusterGroups {release->getClusterGroups(clusterTypes, 3)};
const auto clusterTypes{ ScanSettings::get(LmsApp->getDbSession())->getClusterTypes() };
const auto clusterGroups{ release->getClusterGroups(clusterTypes, 3) };
for (const auto& clusters : clusterGroups)
{
for (const Database::Cluster::pointer& cluster : clusters)
{
const ClusterId clusterId {cluster->getId()};
Wt::WInteractWidget* entry {clusterContainers->addWidget(Utils::createCluster(clusterId))};
const ClusterId clusterId{ cluster->getId() };
Wt::WInteractWidget* entry{ clusterContainers->addWidget(Utils::createCluster(clusterId)) };
entry->clicked().connect([=]
{
_filters.add(clusterId);
@@ -283,29 +277,29 @@ Release::refreshView()
bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML)
->clicked().connect([=]
{
_playQueueController.processCommand(PlayQueueController::Command::Play, {_releaseId});
_playQueueController.processCommand(PlayQueueController::Command::Play, { _releaseId });
});
bindNew<Wt::WPushButton>("play-shuffled", Wt::WString::tr("Lms.Explore.play-shuffled"), Wt::TextFormat::Plain)
->clicked().connect([=]
{
_playQueueController.processCommand(PlayQueueController::Command::PlayShuffled, {_releaseId});
_playQueueController.processCommand(PlayQueueController::Command::PlayShuffled, { _releaseId });
});
bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"), Wt::TextFormat::Plain)
->clicked().connect([=]
{
_playQueueController.processCommand(PlayQueueController::Command::PlayNext, {_releaseId});
_playQueueController.processCommand(PlayQueueController::Command::PlayNext, { _releaseId });
});
bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"), Wt::TextFormat::Plain)
->clicked().connect([=]
{
_playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, {_releaseId});
_playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, { _releaseId });
});
bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
->setLink(Wt::WLink {std::make_unique<DownloadReleaseResource>(_releaseId)});
->setLink(Wt::WLink{ std::make_unique<DownloadReleaseResource>(_releaseId) });
bindNew<Wt::WPushButton>("release-info", Wt::WString::tr("Lms.Explore.release-info"))
->clicked().connect([=]
@@ -314,9 +308,9 @@ Release::refreshView()
});
{
auto isStarred {[=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), _releaseId); }};
auto isStarred{ [=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), _releaseId); } };
Wt::WPushButton* starBtn {bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star"))};
Wt::WPushButton* starBtn{ bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star")) };
starBtn->clicked().connect([=]
{
if (isStarred())
@@ -332,12 +326,12 @@ Release::refreshView()
});
}
Wt::WContainerWidget* rootContainer {bindNew<Wt::WContainerWidget>("container")};
Wt::WContainerWidget* rootContainer{ bindNew<Wt::WContainerWidget>("container") };
const bool variousArtists {release->hasVariousArtists()};
const auto totalDisc {release->getTotalDisc()};
const std::size_t discCount {release->getDiscCount()};
const bool isReleaseMultiDisc {(discCount > 1) || (totalDisc && *totalDisc > 1)};
const bool variousArtists{ release->hasVariousArtists() };
const auto totalDisc{ release->getTotalDisc() };
const std::size_t discCount{ release->getDiscCount() };
const bool isReleaseMultiDisc{ (discCount > 1) || (totalDisc && *totalDisc > 1) };
// Expect to be called in asc order
std::map<std::size_t, Wt::WContainerWidget*> trackContainers;
@@ -349,14 +343,14 @@ Release::refreshView()
return it->second;
}
Wt::WTemplate* disc {rootContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Release.template.entry-disc"))};
Wt::WTemplate* disc{ rootContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Release.template.entry-disc")) };
if (discSubtitle.empty())
disc->bindNew<Wt::WText>("disc-title", Wt::WString::tr("Lms.Explore.Release.disc").arg(discNumber));
else
disc->bindString("disc-title", Wt::WString::fromUTF8(discSubtitle), Wt::TextFormat::Plain);
Wt::WContainerWidget* tracksContainer {disc->bindNew<Wt::WContainerWidget>("tracks")};
Wt::WContainerWidget* tracksContainer{ disc->bindNew<Wt::WContainerWidget>("tracks") };
trackContainers[discNumber] = tracksContainer;
return tracksContainer;
@@ -368,7 +362,7 @@ Release::refreshView()
if (noDiscTracksContainer)
return noDiscTracksContainer;
Wt::WTemplate* disc {rootContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Release.template.entry-nodisc"))};
Wt::WTemplate* disc{ rootContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Release.template.entry-nodisc")) };
noDiscTracksContainer = disc->bindNew<Wt::WContainerWidget>("tracks");
return noDiscTracksContainer;
@@ -379,12 +373,10 @@ Release::refreshView()
params.setSortMethod(Database::TrackSortMethod::Release);
params.setClusters(_filters.getClusterIds());
const auto tracks {Database::Track::find(LmsApp->getDbSession(), params)};
for (const Database::TrackId trackId : tracks.results)
for (const Database::Track::pointer& track : Database::Track::find(LmsApp->getDbSession(), params).results)
{
const Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), trackId)};
const auto discNumber {track->getDiscNumber()};
const Database::TrackId trackId{ track->getId() };
const auto discNumber{ track->getDiscNumber() };
Wt::WContainerWidget* container;
if (isReleaseMultiDisc && discNumber)
@@ -392,26 +384,26 @@ Release::refreshView()
else
container = getOrAddNoDiscContainer();
Template* entry {container->addNew<Template>(Wt::WString::tr("Lms.Explore.Release.template.entry"))};
Template* entry{ container->addNew<Template>(Wt::WString::tr("Lms.Explore.Release.template.entry")) };
entry->bindString("name", Wt::WString::fromUTF8(track->getName()), Wt::TextFormat::Plain);
const auto artists {track->getArtistIds({TrackArtistLinkType::Artist})};
const auto artists{ track->getArtistIds({TrackArtistLinkType::Artist}) };
if (variousArtists && !artists.empty())
{
entry->setCondition("if-has-artists", true);
entry->bindWidget("artists", Utils::createArtistDisplayNameWithAnchors(track->getArtistDisplayName(), artists));
entry->bindWidget("artists-md", Utils::createArtistDisplayNameWithAnchors(track->getArtistDisplayName(),artists));
entry->bindWidget("artists-md", Utils::createArtistDisplayNameWithAnchors(track->getArtistDisplayName(), artists));
}
auto trackNumber {track->getTrackNumber()};
auto trackNumber{ track->getTrackNumber() };
if (trackNumber)
{
entry->setCondition("if-has-track-number", true);
entry->bindInt("track-number", *trackNumber);
}
Wt::WPushButton* playBtn {entry->bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.template.play-btn"), Wt::TextFormat::XHTML)};
Wt::WPushButton* playBtn{ entry->bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.template.play-btn"), Wt::TextFormat::XHTML) };
playBtn->clicked().connect([=]
{
_playQueueController.playTrackInRelease(trackId);
@@ -427,20 +419,20 @@ Release::refreshView()
entry->bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"))
->clicked().connect([=]
{
_playQueueController.processCommand(PlayQueueController::Command::PlayNext, {trackId});
_playQueueController.processCommand(PlayQueueController::Command::PlayNext, { trackId });
});
entry->bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"))
->clicked().connect([=]
{
_playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, {trackId});
_playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, { trackId });
});
auto isStarred {[=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), trackId); }};
auto isStarred{ [=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), trackId); } };
Wt::WPushButton* starBtn {entry->bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star"))};
Wt::WPushButton* starBtn{ entry->bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star")) };
starBtn->clicked().connect([=]
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
if (isStarred())
{
@@ -455,7 +447,7 @@ Release::refreshView()
});
entry->bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
->setLink(Wt::WLink {std::make_unique<DownloadTrackResource>(trackId)});
->setLink(Wt::WLink{ std::make_unique<DownloadTrackResource>(trackId) });
entry->bindNew<Wt::WPushButton>("track-info", Wt::WString::tr("Lms.Explore.track-info"))
->clicked().connect([=] { TrackListHelpers::showTrackInfoModal(trackId, _filters); });
@@ -463,88 +455,83 @@ Release::refreshView()
entry->bindString("duration", Utils::durationToString(track->getDuration()), Wt::TextFormat::Plain);
LmsApp->getMediaPlayer().trackLoaded.connect(entry, [=] (TrackId loadedTrackId)
LmsApp->getMediaPlayer().trackLoaded.connect(entry, [=](TrackId loadedTrackId)
{
entry->toggleStyleClass("Lms-entry-playing", loadedTrackId == trackId);
});
if (auto trackIdLoaded {LmsApp->getMediaPlayer().getTrackLoaded()})
if (auto trackIdLoaded{ LmsApp->getMediaPlayer().getTrackLoaded() })
{
entry->toggleStyleClass("Lms-entry-playing", *trackIdLoaded == trackId);
}
else
entry->removeStyleClass("Lms-entry-playing");
}
}
}
void
Release::refreshReleaseArtists(const Database::Release::pointer& release)
{
void Release::refreshReleaseArtists(const Database::Release::pointer& release)
{
auto container{ Utils::createArtistsAnchorsForRelease(release) };
if (container)
{
setCondition("if-has-release-artists", true);
bindWidget("artists", std::move(container));
}
}
}
void
Release::refreshCopyright(const Database::Release::pointer& release)
{
std::optional<std::string> copyright {release->getCopyright()};
std::optional<std::string> copyrightURL {release->getCopyrightURL()};
void Release::refreshCopyright(const Database::Release::pointer& release)
{
std::optional<std::string> copyright{ release->getCopyright() };
std::optional<std::string> copyrightURL{ release->getCopyrightURL() };
if (!copyright && !copyrightURL)
return;
setCondition("if-has-copyright", true);
std::string copyrightText {copyright ? *copyright : ""};
std::string copyrightText{ copyright ? *copyright : "" };
if (copyrightText.empty() && copyrightURL)
copyrightText = *copyrightURL;
if (copyrightURL)
{
Wt::WLink link {*copyrightURL};
Wt::WLink link{ *copyrightURL };
link.setTarget(Wt::LinkTarget::NewWindow);
Wt::WAnchor* anchor {bindNew<Wt::WAnchor>("copyright", link)};
Wt::WAnchor* anchor{ bindNew<Wt::WAnchor>("copyright", link) };
anchor->setTextFormat(Wt::TextFormat::Plain);
anchor->setText(Wt::WString::fromUTF8(copyrightText));
}
else
bindString("copyright", Wt::WString::fromUTF8(*copyright), Wt::TextFormat::Plain);
}
}
void
Release::refreshLinks(const Database::Release::pointer& release)
{
const auto mbid {release->getMBID()};
void Release::refreshLinks(const Database::Release::pointer& release)
{
const auto mbid{ release->getMBID() };
if (mbid)
{
setCondition("if-has-mbid", true);
bindString("mbid-link", std::string {"https://musicbrainz.org/release/"} + std::string {mbid->getAsString()});
bindString("mbid-link", std::string{ "https://musicbrainz.org/release/" } + std::string{ mbid->getAsString() });
}
}
}
void
Release::refreshSimilarReleases(const std::vector<ReleaseId>& similarReleasesId)
{
void Release::refreshSimilarReleases(const std::vector<ReleaseId>& similarReleasesId)
{
if (similarReleasesId.empty())
return;
setCondition("if-has-similar-releases", true);
auto* similarReleasesContainer {bindNew<Wt::WContainerWidget>("similar-releases")};
auto* similarReleasesContainer{ bindNew<Wt::WContainerWidget>("similar-releases") };
for (const ReleaseId id : similarReleasesId)
{
const Database::Release::pointer similarRelease {Database::Release::find(LmsApp->getDbSession(), id)};
const Database::Release::pointer similarRelease{ Database::Release::find(LmsApp->getDbSession(), id) };
if (!similarRelease)
continue;
similarReleasesContainer->addWidget(ReleaseListHelpers::createEntry(similarRelease));
}
}
}
} // namespace UserInterface
src/lms/ui/explore/TrackCollector.cpp
+13 -16
View File
@@ -35,11 +35,10 @@ namespace UserInterface
{
using namespace Database;
RangeResults<TrackId>
TrackCollector::get(Range range)
RangeResults<TrackId> TrackCollector::get(Range range)
{
Feedback::IFeedbackService& feedbackService{*Service<Feedback::IFeedbackService>::get()};
Scrobbling::IScrobblingService& scrobblingService {*Service<Scrobbling::IScrobblingService>::get()};
Feedback::IFeedbackService& feedbackService{ *Service<Feedback::IFeedbackService>::get() };
Scrobbling::IScrobblingService& scrobblingService{ *Service<Scrobbling::IScrobblingService>::get() };
RangeResults<TrackId> tracks;
range = getActualRange(range);
@@ -72,8 +71,8 @@ namespace UserInterface
params.setRange(range);
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
tracks = Track::find(LmsApp->getDbSession(), params);
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
tracks = Track::findIds(LmsApp->getDbSession(), params);
}
break;
}
@@ -86,8 +85,8 @@ namespace UserInterface
params.setRange(range);
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
tracks = Track::find(LmsApp->getDbSession(), params);
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
tracks = Track::findIds(LmsApp->getDbSession(), params);
}
break;
}
@@ -99,8 +98,8 @@ namespace UserInterface
params.setRange(range);
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
tracks = Track::find(LmsApp->getDbSession(), params);
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
tracks = Track::findIds(LmsApp->getDbSession(), params);
}
break;
}
@@ -112,8 +111,7 @@ namespace UserInterface
return tracks;
}
RangeResults<TrackId>
TrackCollector::getRandomTracks(Range range)
RangeResults<TrackId> TrackCollector::getRandomTracks(Range range)
{
assert(getMode() == Mode::Random);
@@ -122,11 +120,11 @@ namespace UserInterface
Track::FindParameters params;
params.setClusters(getFilters().getClusterIds());
params.setSortMethod(TrackSortMethod::Random);
params.setRange({0, getMaxCount()});
params.setRange({ 0, getMaxCount() });
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
_randomTracks = Track::find(LmsApp->getDbSession(), params);
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
_randomTracks = Track::findIds(LmsApp->getDbSession(), params);
}
}
@@ -134,4 +132,3 @@ namespace UserInterface
}
} // ns UserInterface
src/lms/ui/explore/TrackListView.cpp
+35 -43
View File
@@ -39,24 +39,22 @@
#include "ModalManager.hpp"
#include "Utils.hpp"
using namespace Database;
namespace
namespace UserInterface
{
static
std::optional<TrackListId>
extractTrackListIdFromInternalPath()
using namespace Database;
namespace
{
std::optional<TrackListId> extractTrackListIdFromInternalPath()
{
return StringUtils::readAs<TrackListId::ValueType>(wApp->internalPathNextPart("/tracklist/"));
}
}
}
namespace UserInterface
{
TrackList::TrackList(Filters& filters, PlayQueueController& playQueueController)
: Template {Wt::WString::tr("Lms.Explore.TrackList.template")}
, _filters {filters}
, _playQueueController {playQueueController}
: Template{ Wt::WString::tr("Lms.Explore.TrackList.template") }
, _filters{ filters }
, _playQueueController{ playQueueController }
{
addFunction("tr", &Wt::WTemplate::Functions::tr);
addFunction("id", &Wt::WTemplate::Functions::id);
@@ -74,43 +72,42 @@ namespace UserInterface
refreshView();
}
void
TrackList::refreshView()
void TrackList::refreshView()
{
if (!wApp->internalPathMatches("/tracklist/"))
return;
const std::optional<TrackListId> trackListId {extractTrackListIdFromInternalPath()};
const std::optional<TrackListId> trackListId{ extractTrackListIdFromInternalPath() };
if (!trackListId)
throw TrackListNotFoundException {};
throw TrackListNotFoundException{};
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const Database::TrackList::pointer trackList {Database::TrackList::find(LmsApp->getDbSession(), *trackListId)};
const Database::TrackList::pointer trackList{ Database::TrackList::find(LmsApp->getDbSession(), *trackListId) };
if (!trackList)
throw TrackListNotFoundException {};
throw TrackListNotFoundException{};
LmsApp->setTitle(std::string {trackList->getName()});
LmsApp->setTitle(std::string{ trackList->getName() });
_trackListId = *trackListId;
clear();
bindString("name", std::string {trackList->getName()}, Wt::TextFormat::Plain);
bindString("name", std::string{ trackList->getName() }, Wt::TextFormat::Plain);
bindString("duration", Utils::durationToString(trackList->getDuration()));
const auto trackCount {trackList->getCount()};
const auto trackCount{ trackList->getCount() };
bindString("track-count", Wt::WString::trn("Lms.track-count", trackCount).arg(trackCount));
Wt::WContainerWidget* clusterContainers {bindNew<Wt::WContainerWidget>("clusters")};
Wt::WContainerWidget* clusterContainers{ bindNew<Wt::WContainerWidget>("clusters") };
{
const auto clusterTypes {ScanSettings::get(LmsApp->getDbSession())->getClusterTypes()};
const auto clusterGroups {trackList->getClusterGroups(clusterTypes, 3)};
const auto clusterTypes{ ScanSettings::get(LmsApp->getDbSession())->getClusterTypes() };
const auto clusterGroups{ trackList->getClusterGroups(clusterTypes, 3) };
for (const auto& clusters : clusterGroups)
{
for (const Database::Cluster::pointer& cluster : clusters)
{
const ClusterId clusterId {cluster->getId()};
Wt::WInteractWidget* entry {clusterContainers->addWidget(Utils::createCluster(clusterId))};
const ClusterId clusterId{ cluster->getId() };
Wt::WInteractWidget* entry{ clusterContainers->addWidget(Utils::createCluster(clusterId)) };
entry->clicked().connect([=]
{
_filters.add(clusterId);
@@ -138,22 +135,22 @@ namespace UserInterface
});
bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
->setLink(Wt::WLink {std::make_unique<DownloadTrackListResource>(*trackListId)});
->setLink(Wt::WLink{ std::make_unique<DownloadTrackListResource>(*trackListId) });
bindNew<Wt::WPushButton>("delete", Wt::WString::tr("Lms.delete"))
->clicked().connect([=]
{
auto modal {std::make_unique<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.TrackList.template.delete-tracklist"))};
auto modal{ std::make_unique<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.TrackList.template.delete-tracklist")) };
modal->addFunction("tr", &Wt::WTemplate::Functions::tr);
Wt::WWidget* modalPtr {modal.get()};
Wt::WWidget* modalPtr{ modal.get() };
auto* delBtn {modal->bindNew<Wt::WPushButton>("del-btn", Wt::WString::tr("Lms.delete"))};
auto* delBtn{ modal->bindNew<Wt::WPushButton>("del-btn", Wt::WString::tr("Lms.delete")) };
delBtn->clicked().connect([=]
{
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
Database::TrackList::pointer trackList {Database::TrackList::find(LmsApp->getDbSession(), *trackListId)};
Database::TrackList::pointer trackList{ Database::TrackList::find(LmsApp->getDbSession(), *trackListId) };
if (trackList)
trackList.remove();
}
@@ -165,7 +162,7 @@ namespace UserInterface
LmsApp->getModalManager().dispose(modalPtr);
});
auto* cancelBtn {modal->bindNew<Wt::WPushButton>("cancel-btn", Wt::WString::tr("Lms.cancel"))};
auto* cancelBtn{ modal->bindNew<Wt::WPushButton>("cancel-btn", Wt::WString::tr("Lms.cancel")) };
cancelBtn->clicked().connect([=]
{
LmsApp->getModalManager().dispose(modalPtr);
@@ -181,24 +178,19 @@ namespace UserInterface
});
}
void
TrackList::addSome()
void TrackList::addSome()
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
Database::Track::FindParameters params;
params.setClusters(_filters.getClusterIds());
params.setTrackList(_trackListId);
params.setSortMethod(Database::TrackSortMethod::TrackList);
params.setRange({static_cast<std::size_t>(_container->getCount()), _batchSize});
params.setRange({ static_cast<std::size_t>(_container->getCount()), _batchSize });
params.setDistinct(false);
const auto trackIds {Database::Track::find(LmsApp->getDbSession(), params)};
for (const TrackId trackId : trackIds.results)
{
if (const Track::pointer track {Track::find(LmsApp->getDbSession(), trackId)})
for (const Track::pointer& track : Database::Track::find(LmsApp->getDbSession(), params).results)
_container->add(TrackListHelpers::createEntry(track, _playQueueController, _filters));
}
}
} // namespace UserInterface
src/lms/ui/resource/DownloadResource.cpp
+81 -114
View File
@@ -19,10 +19,6 @@
#include "DownloadResource.hpp"
#include <array>
#include <iostream>
#include <iomanip>
#include <Wt/Http/Response.h>
#include <Wt/WDateTime.h>
@@ -38,22 +34,22 @@
#define LOG(level) LMS_LOG(UI, level) << "Download resource: "
namespace UserInterface {
DownloadResource::~DownloadResource()
namespace UserInterface
{
DownloadResource::~DownloadResource()
{
beingDeleted();
}
}
void
DownloadResource::handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response)
{
void DownloadResource::handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response)
{
try
{
std::shared_ptr<Zip::IZipper> zipper;
// First, see if this request is for a continuation
if (Wt::Http::ResponseContinuation *continuation {request.continuation()})
if (Wt::Http::ResponseContinuation * continuation{ request.continuation() })
zipper = Wt::cpp17::any_cast<std::shared_ptr<Zip::IZipper>>(continuation->data());
else
{
@@ -64,7 +60,7 @@ DownloadResource::handleRequest(const Wt::Http::Request& request, Wt::Http::Resp
zipper->writeSome(response.out());
if (!zipper->isComplete())
{
auto* continuation {response.createContinuation()};
auto* continuation{ response.createContinuation() };
continuation->setData(zipper);
}
}
@@ -72,19 +68,17 @@ DownloadResource::handleRequest(const Wt::Http::Request& request, Wt::Http::Resp
{
LOG(ERROR) << "Zipper exception: " << exception.what();
}
}
}
static
std::string
getArtistPathName(Database::Artist::pointer artist)
{
namespace
{
std::string getArtistPathName(Database::Artist::pointer artist)
{
return StringUtils::replaceInString(artist->getName(), "/", "_");
}
}
static
std::string
getReleaseArtistPathName(Database::Release::pointer release)
{
std::string getReleaseArtistPathName(Database::Release::pointer release)
{
std::string releaseArtistName;
std::vector<Database::ObjectPtr<Database::Artist>> artists;
@@ -101,32 +95,29 @@ getReleaseArtistPathName(Database::Release::pointer release)
releaseArtistName = StringUtils::replaceInString(releaseArtistName, "/", "_");
return releaseArtistName;
}
}
static
std::string
getReleasePathName(Database::Release::pointer release)
{
std::string getReleasePathName(Database::Release::pointer release)
{
std::string releaseName;
if (const Wt::WDate releaseDate {release->getReleaseDate()}; releaseDate.isValid())
if (const Wt::WDate releaseDate{ release->getReleaseDate() }; releaseDate.isValid())
releaseName += std::to_string(releaseDate.year()) + " - ";
releaseName += StringUtils::replaceInString(release->getName(), "/", "_");
return releaseName;
}
}
}
namespace details
{
static
std::string
getTrackPathName(Database::Track::pointer track)
namespace details
{
std::string getTrackPathName(Database::Track::pointer track)
{
std::ostringstream fileName;
if (auto discNumber {track->getDiscNumber()})
if (auto discNumber{ track->getDiscNumber() })
fileName << *discNumber << ".";
if (auto trackNumber {track->getTrackNumber()})
if (auto trackNumber{ track->getTrackNumber() })
fileName << std::setw(2) << std::setfill('0') << *trackNumber << " - ";
fileName << StringUtils::replaceInString(track->getName(), "/", "_") << track->getPath().filename().extension().string();
@@ -134,16 +125,12 @@ namespace details
return fileName.str();
}
static
std::string
getTrackListPathName(Database::TrackList::pointer trackList)
std::string getTrackListPathName(Database::TrackList::pointer trackList)
{
return StringUtils::replaceInString(trackList->getName(), "/", "_");
}
static
std::unique_ptr<Zip::IZipper>
createZipper(const std::vector<Database::Track::pointer>& tracks)
std::unique_ptr<Zip::IZipper> createZipper(const std::vector<Database::Track::pointer>& tracks)
{
if (tracks.empty())
return {};
@@ -153,7 +140,7 @@ namespace details
{
std::string releaseName;
std::string releaseArtistName;
if (auto release {track->getRelease()})
if (auto release{ track->getRelease() })
{
releaseName = getReleasePathName(release);
releaseArtistName = getReleaseArtistPathName(release);
@@ -166,115 +153,95 @@ namespace details
fileName += releaseName + "/";
fileName += getTrackPathName(track);
files.emplace_back(Zip::Entry {fileName, track->getPath()});
files.emplace_back(Zip::Entry{ fileName, track->getPath() });
}
return Zip::createArchiveZipper(files);
}
}
}
DownloadArtistResource::DownloadArtistResource(Database::ArtistId artistId)
: _artistId {artistId}
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
DownloadArtistResource::DownloadArtistResource(Database::ArtistId artistId)
: _artistId{ artistId }
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
Database::Artist::pointer artist {Database::Artist::find(LmsApp->getDbSession(), artistId)};
Database::Artist::pointer artist{ Database::Artist::find(LmsApp->getDbSession(), artistId) };
if (artist)
suggestFileName(getArtistPathName(artist) + ".zip");
}
}
std::unique_ptr<Zip::IZipper>
DownloadArtistResource::createZipper()
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
std::unique_ptr<Zip::IZipper> DownloadArtistResource::createZipper()
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const auto trackResults {Database::Track::find(LmsApp->getDbSession(), Database::Track::FindParameters {}.setArtist(_artistId).setSortMethod(Database::TrackSortMethod::DateDescAndRelease))};
std::vector<Database::Track::pointer> tracks;
tracks.reserve(trackResults.results.size());
const auto trackResults{ Database::Track::find(LmsApp->getDbSession(), Database::Track::FindParameters {}.setArtist(_artistId).setSortMethod(Database::TrackSortMethod::DateDescAndRelease)) };
return details::createZipper(trackResults.results);
}
for (const Database::TrackId trackId : trackResults.results)
tracks.push_back(Database::Track::find(LmsApp->getDbSession(), trackId));
DownloadReleaseResource::DownloadReleaseResource(Database::ReleaseId releaseId)
: _releaseId{ releaseId }
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
return details::createZipper(tracks);
}
DownloadReleaseResource::DownloadReleaseResource(Database::ReleaseId releaseId)
: _releaseId {releaseId}
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), releaseId)};
Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), releaseId) };
if (release)
suggestFileName(getReleasePathName(release) + ".zip");
}
}
std::unique_ptr<Zip::IZipper>
DownloadReleaseResource::createZipper()
{
std::unique_ptr<Zip::IZipper> DownloadReleaseResource::createZipper()
{
using namespace Database;
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
auto trackResults {Track::find(LmsApp->getDbSession(), Track::FindParameters {}.setRelease(_releaseId).setSortMethod(TrackSortMethod::Release))};
auto tracks{ Track::find(LmsApp->getDbSession(), Track::FindParameters {}.setRelease(_releaseId).setSortMethod(TrackSortMethod::Release)) };
return details::createZipper(tracks.results);
}
std::vector<Track::pointer> tracks;
tracks.reserve(trackResults.results.size());
std::transform(std::cbegin(trackResults.results), std::cend(trackResults.results), std::back_inserter(tracks), [](TrackId trackId){ return Track::find(LmsApp->getDbSession(), trackId); });
DownloadTrackResource::DownloadTrackResource(Database::TrackId trackId)
: _trackId{ trackId }
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
return details::createZipper(tracks);
}
DownloadTrackResource::DownloadTrackResource(Database::TrackId trackId)
: _trackId {trackId}
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), trackId)};
Database::Track::pointer track{ Database::Track::find(LmsApp->getDbSession(), trackId) };
if (track)
suggestFileName(details::getTrackPathName(track) + ".zip");
}
}
std::unique_ptr<Zip::IZipper>
DownloadTrackResource::createZipper()
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
std::unique_ptr<Zip::IZipper> DownloadTrackResource::createZipper()
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), _trackId)};
const Database::Track::pointer track{ Database::Track::find(LmsApp->getDbSession(), _trackId) };
if (!track)
{
LOG(DEBUG) << "Cannot find track";
return {};
}
return details::createZipper({track});
}
return details::createZipper({ track });
}
DownloadTrackListResource::DownloadTrackListResource(Database::TrackListId trackListId)
: _trackListId {trackListId}
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
DownloadTrackListResource::DownloadTrackListResource(Database::TrackListId trackListId)
: _trackListId{ trackListId }
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const Database::TrackList::pointer trackList {Database::TrackList::find(LmsApp->getDbSession(), trackListId)};
const Database::TrackList::pointer trackList{ Database::TrackList::find(LmsApp->getDbSession(), trackListId) };
if (trackList)
suggestFileName(details::getTrackListPathName(trackList) + ".zip");
}
}
std::unique_ptr<Zip::IZipper>
DownloadTrackListResource::createZipper()
{
std::unique_ptr<Zip::IZipper> DownloadTrackListResource::createZipper()
{
using namespace Database;
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
Track::FindParameters params;
params.setTrackList(_trackListId);
const auto trackResults {Track::find(LmsApp->getDbSession(), params)};
std::vector<Track::pointer> tracks;
tracks.reserve(trackResults.results.size());
std::transform(std::cbegin(trackResults.results), std::cend(trackResults.results), std::back_inserter(tracks), [](TrackId trackId){ return Track::find(LmsApp->getDbSession(), trackId); });
return details::createZipper(tracks);
}
const auto tracks{ Track::find(LmsApp->getDbSession(), params) };
return details::createZipper(tracks.results);
}
} // namespace UserInterface
src/tools/cover/LmsCover.cpp
+1 -1
View File
@@ -43,7 +43,7 @@ dumpTrackCovers(Database::Session& session, Image::ImageSize width)
RangeResults<Database::TrackId> trackIds;
{
auto transaction {session.createSharedTransaction()};
trackIds = Database::Track::find(session, Database::Track::FindParameters {});
trackIds = Database::Track::findIds(session, Database::Track::FindParameters {});
}
for (const Database::TrackId trackId : trackIds.results)
src/tools/recommendation/LmsRecommendation.cpp
+4 -11
View File
@@ -38,14 +38,12 @@
using namespace Database;
static
void
dumpTracksRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
static void dumpTracksRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
{
const RangeResults<TrackId> trackIds{ [&]
{
auto transaction {session.createSharedTransaction()};
return Track::find(session, Track::FindParameters {});
return Track::findIds(session, Track::FindParameters{});
}() };
std::cout << "*** Tracks (" << trackIds.results.size() << ") ***" << std::endl;
@@ -74,9 +72,7 @@ dumpTracksRecommendation(Session session, Recommendation::IRecommendationService
}
}
static
void
dumpReleasesRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
static void dumpReleasesRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
{
const RangeResults<ReleaseId> releaseIds{ std::invoke([&]
{
@@ -101,9 +97,7 @@ dumpReleasesRecommendation(Session session, Recommendation::IRecommendationServi
}
}
static
void
dumpArtistsRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
static void dumpArtistsRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
{
const RangeResults<ArtistId> artistIds = std::invoke([&]()
{
@@ -130,7 +124,6 @@ dumpArtistsRecommendation(Session session, Recommendation::IRecommendationServic
}
}
int main(int argc, char* argv[])
{
try