owen/lms
1
0
Fork 0
Code Issues Pull Requests Actions 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
+396 -416
View File
@@ -34,445 +34,425 @@
#include "utils/String.hpp"
#include "utils/Utils.hpp"
namespace
namespace Cover
{
struct TrackInfo
{
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> res;
namespace
{
struct TrackInfo
{
bool hasCover{};
bool isMultiDisc{};
std::filesystem::path trackPath;
std::optional<Database::ReleaseId> releaseId;
};
auto transaction {dbSession.createSharedTransaction()};
std::optional<TrackInfo> getTrackInfo(Database::Session& dbSession, Database::TrackId trackId)
{
std::optional<TrackInfo> res;
const Database::Track::pointer track {Database::Track::find(dbSession, trackId)};
if (!track)
return res;
auto transaction{ dbSession.createSharedTransaction() };
res = TrackInfo {};
const Database::Track::pointer track{ Database::Track::find(dbSession, trackId) };
if (!track)
return res;
res->hasCover = track->hasCover();
res->trackPath = track->getPath();
res = TrackInfo{};
if (const Database::Release::pointer& release {track->getRelease()})
{
res->releaseId = release->getId();
if (release->getTotalDisc() > 1)
res->isMultiDisc = true;
}
res->hasCover = track->hasCover();
res->trackPath = track->getPath();
return res;
}
if (const Database::Release::pointer & release{ track->getRelease() })
{
res->releaseId = release->getId();
if (release->getTotalDisc() > 1)
res->isMultiDisc = true;
}
std::vector<std::string> constructPreferredFileNames()
{
std::vector<std::string> res;
return res;
}
Service<IConfig>::get()->visitStrings("cover-preferred-file-names",
[&res](std::string_view fileName)
{
res.emplace_back(fileName);
}, {"cover", "front"});
std::vector<std::string> constructPreferredFileNames()
{
std::vector<std::string> res;
return res;
}
}
Service<IConfig>::get()->visitStrings("cover-preferred-file-names",
[&res](std::string_view fileName)
{
res.emplace_back(fileName);
}, { "cover", "front" });
namespace Cover {
return res;
}
using namespace Image;
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));
}
}
static
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)
{
return std::make_unique<CoverService>(db, execPath, 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);
}
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()}
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() }
{
setJpegQuality(Service<IConfig>::get()->getULong("cover-jpeg-quality", 75));
{
setJpegQuality(Service<IConfig>::get()->getULong("cover-jpeg-quality", 75));
LMS_LOG(COVER, INFO) << "Default cover path = '" << _defaultCoverPath.string() << "'";
LMS_LOG(COVER, INFO) << "Max cache size = " << _maxCacheSize;
LMS_LOG(COVER, INFO) << "Max file size = " << _maxFileSize;
LMS_LOG(COVER, INFO) << "Preferred file names: " << StringUtils::joinStrings(_preferredFileNames, ",");
LMS_LOG(COVER, INFO) << "Default cover path = '" << _defaultCoverPath.string() << "'";
LMS_LOG(COVER, INFO) << "Max cache size = " << _maxCacheSize;
LMS_LOG(COVER, INFO) << "Max file size = " << _maxFileSize;
LMS_LOG(COVER, INFO) << "Preferred file names: " << StringUtils::joinStrings(_preferredFileNames, ",");
#if LMS_SUPPORT_IMAGE_GM
GraphicsMagick::init(execPath);
GraphicsMagick::init(execPath);
#else
(void)execPath;
(void)execPath;
#endif
try
{
getDefault(512);
}
catch (const Image::ImageException& e)
{
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> image;
input.visitAttachedPictures([&](const Av::Picture& picture)
{
if (image)
return;
try
{
std::unique_ptr<IRawImage> rawImage {decodeImage(picture.data, picture.dataSize)};
rawImage->resize(width);
image = rawImage->encodeToJPEG(_jpegQuality);
}
catch (const Image::ImageException& e)
{
LMS_LOG(COVER, ERROR) << "Cannot read embedded cover: " << e.what();
}
});
return image;
}
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)};
rawImage->resize(width);
image = rawImage->encodeToJPEG(_jpegQuality);
}
catch (const ImageException& e)
{
LMS_LOG(COVER, ERROR) << "Cannot read cover in file '" << p.string() << "': " << e.what();
}
return image;
}
std::shared_ptr<IEncodedImage>
CoverService::getDefault(ImageSize width)
{
{
std::shared_lock lock {_cacheMutex};
if (auto it {_defaultCoverCache.find(width)}; it != std::cend(_defaultCoverCache))
return it->second;
}
{
std::unique_lock lock {_cacheMutex};
if (auto it {_defaultCoverCache.find(width)}; it != std::cend(_defaultCoverCache))
return it->second;
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)};
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)
{
image = getFromCoverFile(it->second, width);
if (image)
break;
}
return image;
};
std::unique_ptr<IEncodedImage> image;
for (std::string_view filename : _preferredFileNames)
{
image = tryLoadImageFromFilename(filename);
if (image)
return image;
}
// Just pick one
for (const auto& [filename, coverPath] : coverPaths)
{
image = getFromCoverFile(coverPath, width);
if (image)
return image;
}
return image;
}
std::unique_ptr<IEncodedImage>
CoverService::getFromSameNamedFile(const std::filesystem::path& filePath, ImageSize width) const
{
std::unique_ptr<IEncodedImage> res;
std::filesystem::path coverPath {filePath};
for (const std::filesystem::path& extension : _fileExtensions)
{
coverPath.replace_extension(extension);
if (!checkCoverFile(coverPath))
continue;
res = getFromCoverFile(coverPath, width);
if (res)
break;
}
return res;
}
bool
CoverService::checkCoverFile(const std::filesystem::path& filePath) const
{
std::error_code ec;
if (!isFileSupported(filePath, _fileExtensions))
return false;
if (!std::filesystem::exists(filePath, ec))
return false;
if (!std::filesystem::is_regular_file(filePath, ec))
return false;
if (std::filesystem::file_size(filePath, ec) > _maxFileSize && !ec)
{
LMS_LOG(COVER, INFO) << "Cover file '" << filePath.string() << " is too big (" << std::filesystem::file_size(filePath, ec) << "), limit is " << _maxFileSize;
return false;
}
return true;
}
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;
std::filesystem::directory_iterator itPath(directoryPath, ec);
std::filesystem::directory_iterator itEnd;
while (!ec && itPath != itEnd)
{
const std::filesystem::path& path {*itPath};
if (checkCoverFile(path))
res.emplace(std::filesystem::path{ path }.filename().replace_extension("").string(), path);
itPath.increment(ec);
}
return res;
}
std::unique_ptr<IEncodedImage>
CoverService::getFromTrack(const std::filesystem::path& p, ImageSize width) const
{
std::unique_ptr<IEncodedImage> image;
try
{
image = getFromAvMediaFile(*Av::parseAudioFile(p), width);
}
catch (Av::Exception& e)
{
LMS_LOG(COVER, ERROR) << "Cannot get covers from track " << p.string() << ": " << e.what();
}
return image;
}
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)
{
using namespace Database;
const CacheEntryDesc cacheEntryDesc {trackId, width};
std::shared_ptr<IEncodedImage> cover {loadFromCache(cacheEntryDesc)};
if (cover)
return cover;
if (const std::optional<TrackInfo> trackInfo {getTrackInfo(dbSession, trackId)})
{
if (trackInfo->hasCover)
cover = getFromTrack(trackInfo->trackPath, width);
if (!cover)
cover = getFromSameNamedFile(trackInfo->trackPath, width);
if (!cover && trackInfo->releaseId && allowReleaseFallback)
cover = getFromRelease(*trackInfo->releaseId, width);
if (!cover && trackInfo->isMultiDisc)
{
if (trackInfo->trackPath.parent_path().has_parent_path())
cover = getFromDirectory(trackInfo->trackPath.parent_path().parent_path(), width);
}
}
if (!cover)
cover = getDefault(width);
if (cover)
saveToCache(cacheEntryDesc, cover);
return cover;
}
std::shared_ptr<IEncodedImage>
CoverService::getFromRelease(Database::ReleaseId releaseId, ImageSize width)
{
using namespace Database;
const CacheEntryDesc cacheEntryDesc {releaseId, width};
std::shared_ptr<IEncodedImage> cover {loadFromCache(cacheEntryDesc)};
if (cover)
return cover;
struct ReleaseInfo
{
TrackId firstTrackId;
std::filesystem::path releaseDirectory;
};
Session& session {_db.getTLSSession()};
auto getReleaseInfo {[&]
{
std::optional<ReleaseInfo> res;
auto transaction {session.createSharedTransaction()};
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 {};
res->firstTrackId = track->getId();
res->releaseDirectory = track->getPath().parent_path();
}
}
return res;
}};
if (const std::optional<ReleaseInfo> releaseInfo {getReleaseInfo()})
{
cover = getFromDirectory(releaseInfo->releaseDirectory, width);
if (!cover)
cover = getFromTrack(session, releaseInfo->firstTrackId, width, false /* no release fallback */);
}
if (!cover)
cover = getDefault(width);
if (cover)
saveToCache(cacheEntryDesc, cover);
return cover;
}
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)
{
_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};
while (_cacheSize + image->getDataSize() > _maxCacheSize && !_cache.empty())
{
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};
auto it {_cache.find(entryDesc)};
if (it == std::cend(_cache))
{
++_cacheMisses;
return nullptr;
}
++_cacheHits;
return it->second;
}
try
{
getDefault(512);
}
catch (const Image::ImageException& e)
{
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> image;
input.visitAttachedPictures([&](const Av::Picture& picture)
{
if (image)
return;
try
{
std::unique_ptr<IRawImage> rawImage{ decodeImage(picture.data, picture.dataSize) };
rawImage->resize(width);
image = rawImage->encodeToJPEG(_jpegQuality);
}
catch (const Image::ImageException& e)
{
LMS_LOG(COVER, ERROR) << "Cannot read embedded cover: " << e.what();
}
});
return image;
}
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) };
rawImage->resize(width);
image = rawImage->encodeToJPEG(_jpegQuality);
}
catch (const ImageException& e)
{
LMS_LOG(COVER, ERROR) << "Cannot read cover in file '" << p.string() << "': " << e.what();
}
return image;
}
std::shared_ptr<IEncodedImage> CoverService::getDefault(ImageSize width)
{
{
std::shared_lock lock{ _cacheMutex };
if (auto it{ _defaultCoverCache.find(width) }; it != std::cend(_defaultCoverCache))
return it->second;
}
{
std::unique_lock lock{ _cacheMutex };
if (auto it{ _defaultCoverCache.find(width) }; it != std::cend(_defaultCoverCache))
return it->second;
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) };
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)
{
image = getFromCoverFile(it->second, width);
if (image)
break;
}
return image;
};
std::unique_ptr<IEncodedImage> image;
for (std::string_view filename : _preferredFileNames)
{
image = tryLoadImageFromFilename(filename);
if (image)
return image;
}
// Just pick one
for (const auto& [filename, coverPath] : coverPaths)
{
image = getFromCoverFile(coverPath, width);
if (image)
return image;
}
return image;
}
std::unique_ptr<IEncodedImage> CoverService::getFromSameNamedFile(const std::filesystem::path& filePath, ImageSize width) const
{
std::unique_ptr<IEncodedImage> res;
std::filesystem::path coverPath{ filePath };
for (const std::filesystem::path& extension : _fileExtensions)
{
coverPath.replace_extension(extension);
if (!checkCoverFile(coverPath))
continue;
res = getFromCoverFile(coverPath, width);
if (res)
break;
}
return res;
}
bool CoverService::checkCoverFile(const std::filesystem::path& filePath) const
{
std::error_code ec;
if (!isFileSupported(filePath, _fileExtensions))
return false;
if (!std::filesystem::exists(filePath, ec))
return false;
if (!std::filesystem::is_regular_file(filePath, ec))
return false;
if (std::filesystem::file_size(filePath, ec) > _maxFileSize && !ec)
{
LMS_LOG(COVER, INFO) << "Cover file '" << filePath.string() << " is too big (" << std::filesystem::file_size(filePath, ec) << "), limit is " << _maxFileSize;
return false;
}
return true;
}
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;
std::filesystem::directory_iterator itPath(directoryPath, ec);
std::filesystem::directory_iterator itEnd;
while (!ec && itPath != itEnd)
{
const std::filesystem::path& path{ *itPath };
if (checkCoverFile(path))
res.emplace(std::filesystem::path{ path }.filename().replace_extension("").string(), path);
itPath.increment(ec);
}
return res;
}
std::unique_ptr<IEncodedImage> CoverService::getFromTrack(const std::filesystem::path& p, ImageSize width) const
{
std::unique_ptr<IEncodedImage> image;
try
{
image = getFromAvMediaFile(*Av::parseAudioFile(p), width);
}
catch (Av::Exception& e)
{
LMS_LOG(COVER, ERROR) << "Cannot get covers from track " << p.string() << ": " << e.what();
}
return image;
}
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)
{
using namespace Database;
const CacheEntryDesc cacheEntryDesc{ trackId, width };
std::shared_ptr<IEncodedImage> cover{ loadFromCache(cacheEntryDesc) };
if (cover)
return cover;
if (const std::optional<TrackInfo> trackInfo{ getTrackInfo(dbSession, trackId) })
{
if (trackInfo->hasCover)
cover = getFromTrack(trackInfo->trackPath, width);
if (!cover)
cover = getFromSameNamedFile(trackInfo->trackPath, width);
if (!cover && trackInfo->releaseId && allowReleaseFallback)
cover = getFromRelease(*trackInfo->releaseId, width);
if (!cover && trackInfo->isMultiDisc)
{
if (trackInfo->trackPath.parent_path().has_parent_path())
cover = getFromDirectory(trackInfo->trackPath.parent_path().parent_path(), width);
}
}
if (!cover)
cover = getDefault(width);
if (cover)
saveToCache(cacheEntryDesc, cover);
return cover;
}
std::shared_ptr<IEncodedImage> CoverService::getFromRelease(Database::ReleaseId releaseId, ImageSize width)
{
using namespace Database;
const CacheEntryDesc cacheEntryDesc{ releaseId, width };
std::shared_ptr<IEncodedImage> cover{ loadFromCache(cacheEntryDesc) };
if (cover)
return cover;
struct ReleaseInfo
{
TrackId firstTrackId;
std::filesystem::path releaseDirectory;
};
Session& session{ _db.getTLSSession() };
auto getReleaseInfo{ [&]
{
std::optional<ReleaseInfo> res;
auto transaction{ session.createSharedTransaction() };
const auto tracks{ Track::find(session, Track::FindParameters {}.setRelease(releaseId).setRange({0, 1}).setSortMethod(TrackSortMethod::Release)) };
if (!tracks.results.empty())
{
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() })
{
cover = getFromDirectory(releaseInfo->releaseDirectory, width);
if (!cover)
cover = getFromTrack(session, releaseInfo->firstTrackId, width, false /* no release fallback */);
}
if (!cover)
cover = getDefault(width);
if (cover)
saveToCache(cacheEntryDesc, cover);
return cover;
}
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)
{
_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 };
while (_cacheSize + image->getDataSize() > _maxCacheSize && !_cache.empty())
{
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 };
auto it{ _cache.find(entryDesc) };
if (it == std::cend(_cache))
{
++_cacheMisses;
return nullptr;
}
++_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
+306 -307
View File
@@ -23,415 +23,414 @@ using namespace Database;
TEST_F(DatabaseFixture, Artist)
{
{
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);
}
{
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());
EXPECT_EQ(artist.get()->getId(), artist.getId());
EXPECT_TRUE(artist.get());
EXPECT_FALSE(!artist.get());
EXPECT_EQ(artist.get()->getId(), artist.getId());
EXPECT_TRUE(Artist::exists(session, artist.getId()));
EXPECT_EQ(Artist::getCount(session), 1);
}
EXPECT_TRUE(Artist::exists(session, artist.getId()));
EXPECT_EQ(Artist::getCount(session), 1);
}
{
auto transaction {session.createSharedTransaction()};
{
auto transaction{ session.createSharedTransaction() };
auto artists {Artist::find(session, Artist::FindParameters {})};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
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 {});
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
}
artists = Artist::findAllOrphans(session, Range{});
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
}
}
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);
}
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})};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
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()};
EXPECT_EQ(artistLink->getTrack()->getId(), track.getId());
EXPECT_EQ(artistLink->getArtist()->getId(), artist.getId());
ASSERT_EQ(track->getArtistLinks().size(), 1);
auto artistLink{ track->getArtistLinks().front() };
EXPECT_EQ(artistLink->getTrack()->getId(), track.getId());
EXPECT_EQ(artistLink->getArtist()->getId(), artist.getId());
ASSERT_EQ(track->getArtists({TrackArtistLinkType::Artist}).size(), 1);
EXPECT_TRUE(track->getArtists({TrackArtistLinkType::ReleaseArtist}).empty());
EXPECT_EQ(track->getArtists({}).size(), 1);
}
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})};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front(), artist.getId());
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());
EXPECT_EQ(track->getArtistIds({}).size(), 1);
}
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"))};
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"))};
EXPECT_EQ(tracks.results.size(), 0);
}
{
auto transaction {session.createSharedTransaction()};
auto tracks {Track::find(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()))};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
}
{
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::findIds(session, Track::FindParameters{}.setName("MyTrackName").setArtistName("MyArtistFoo")) };
EXPECT_EQ(tracks.results.size(), 0);
}
{
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())) };
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
}
}
TEST_F(DatabaseFixture, Artist_singleTracktMultiRoles)
{
ScopedTrack track {session, "MyTrack"};
ScopedArtist artist {session, "MyArtist"};
{
auto transaction {session.createUniqueTransaction()};
ScopedTrack track{ session, "MyTrack" };
ScopedArtist artist{ session, "MyArtist" };
{
auto transaction{ session.createUniqueTransaction() };
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::ReleaseArtist);
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Writer);
}
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::ReleaseArtist);
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Writer);
}
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Artist::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})};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
auto artists{ track->getArtists({TrackArtistLinkType::Artist}) };
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
artists = track->getArtists({TrackArtistLinkType::ReleaseArtist});
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
artists = track->getArtists({ TrackArtistLinkType::ReleaseArtist });
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
EXPECT_EQ(track->getArtistLinks().size(), 3);
EXPECT_EQ(track->getArtistLinks().size(), 3);
auto tracks {Track::find(session, Track::FindParameters {}.setArtist(artist.getId()))};
EXPECT_EQ(tracks.results.size(), 1);
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}));
EXPECT_EQ(tracks.results.size(), 1);
tracks = Track::find(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}));
EXPECT_EQ(tracks.results.size(), 1);
tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::ReleaseArtist }));
EXPECT_EQ(tracks.results.size(), 1);
tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Artist }));
EXPECT_EQ(tracks.results.size(), 1);
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}));
EXPECT_EQ(tracks.results.size(), 0);
}
tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Composer }));
EXPECT_EQ(tracks.results.size(), 0);
}
{
auto transaction {session.createSharedTransaction()};
EnumSet<TrackArtistLinkType> types{ TrackArtistLink::findUsedTypes(session, artist.getId()) };
EXPECT_TRUE(types.contains(TrackArtistLinkType::ReleaseArtist));
EXPECT_TRUE(types.contains(TrackArtistLinkType::Artist));
EXPECT_TRUE(types.contains(TrackArtistLinkType::Writer));
EXPECT_FALSE(types.contains(TrackArtistLinkType::Composer));
}
{
auto transaction{ session.createSharedTransaction() };
EnumSet<TrackArtistLinkType> types{ TrackArtistLink::findUsedTypes(session, artist.getId()) };
EXPECT_TRUE(types.contains(TrackArtistLinkType::ReleaseArtist));
EXPECT_TRUE(types.contains(TrackArtistLinkType::Artist));
EXPECT_TRUE(types.contains(TrackArtistLinkType::Writer));
EXPECT_FALSE(types.contains(TrackArtistLinkType::Composer));
}
}
TEST_F(DatabaseFixture, Artist_singleTrackMultiArtists)
{
ScopedTrack track {session, "track"};
ScopedArtist artist1 {session, "artist1"};
ScopedArtist artist2 {session, "artist2"};
ASSERT_NE(artist1.getId(), artist2.getId());
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);
}
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})};
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()));
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({}).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()))};
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track->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()));
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track->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}));
EXPECT_EQ(tracks.results.size(), 0);
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}));
EXPECT_EQ(tracks.results.size(), 1);
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}));
EXPECT_EQ(tracks.results.size(), 0);
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}));
EXPECT_EQ(tracks.results.size(), 1);
}
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()};
artist.get().modify()->setSortName("ZZZ");
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
}
{
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"}))};
ASSERT_EQ(artistsByAAA.results.size(), 1);
EXPECT_EQ(artistsByAAA.results.front(), artist.getId());
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"}))};
ASSERT_EQ(artistsByZZZ.results.size(), 1);
EXPECT_EQ(artistsByZZZ.results.front(), artist.getId());
const auto artistsByZZZ{ Artist::Artist::find(session, Artist::FindParameters {}.setKeywords({"Z"})) };
ASSERT_EQ(artistsByZZZ.results.size(), 1);
EXPECT_EQ(artistsByZZZ.results.front(), artist.getId());
EXPECT_TRUE(Artist::find(session, "NNN").empty());
EXPECT_EQ(Artist::find(session, "AAA").size(), 1);
}
EXPECT_TRUE(Artist::find(session, "NNN").empty());
EXPECT_EQ(Artist::find(session, "AAA").size(), 1);
}
}
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()};
{
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")};
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")};
ASSERT_TRUE(artists.size() == 1);
ASSERT_EQ(artists.front()->getId(), artist3.getId());
EXPECT_TRUE(Artist::find(session, "%CMyArtist").empty());
}
}
{
auto transaction{ session.createSharedTransaction() };
{
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") };
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") };
ASSERT_TRUE(artists.size() == 1);
ASSERT_EQ(artists.front()->getId(), artist3.getId());
EXPECT_TRUE(Artist::find(session, "%CMyArtist").empty());
}
}
{
auto transaction {session.createSharedTransaction()};
{
const auto artists {Artist::find(session, Artist::FindParameters {}.setKeywords({"MyArtist"}))};
EXPECT_EQ(artists.results.size(), 6);
}
{
auto transaction{ session.createSharedTransaction() };
{
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))};
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)) };
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))};
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)) };
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))};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results[0], artist3.getId());
}
}
{
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());
}
}
}
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");
}
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());
EXPECT_EQ(allArtistsByName.results.back(), artistB.getId());
ASSERT_EQ(allArtistsByName.results.size(), 2);
EXPECT_EQ(allArtistsByName.results.front(), artistA.getId());
EXPECT_EQ(allArtistsByName.results.back(), artistB.getId());
ASSERT_EQ(allArtistsBySortName.results.size(), 2);
EXPECT_EQ(allArtistsBySortName.results.front(), artistB.getId());
EXPECT_EQ(allArtistsBySortName.results.back(), artistA.getId());
}
ASSERT_EQ(allArtistsBySortName.results.size(), 2);
EXPECT_EQ(allArtistsBySortName.results.front(), artistB.getId());
EXPECT_EQ(allArtistsBySortName.results.back(), artistA.getId());
}
}
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()))};
EXPECT_EQ(tracks.results.size(), 0);
}
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);
TrackArtistLink::create(session, track1.get(), artist.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track2.get(), artist.get(), TrackArtistLinkType::Artist);
track1.get().modify()->setRelease(release.get());
}
track1.get().modify()->setRelease(release.get());
}
{
auto transaction {session.createSharedTransaction()};
{
auto transaction{ session.createSharedTransaction() };
const auto tracks {Track::find(session, Track::FindParameters {}.setArtist(artist.getId()).setNonRelease(true))};
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track2.getId());
}
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());
}
}
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()))};
EXPECT_EQ(artists.results.size(), 0);
}
{
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()};
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
}
{
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()))};
EXPECT_EQ(artists.results.size(), 0);
}
{
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()};
track.get().modify()->setRelease(release.get());
}
{
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()))};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.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
+101 -100
View File
@@ -25,137 +25,138 @@ using namespace Database;
TEST_F(DatabaseFixture, Track)
{
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(Track::find(session, Track::FindParameters {}).results.size(), 0);
EXPECT_EQ(Track::getCount(session), 0);
EXPECT_FALSE(Track::exists(session, 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::getCount(session), 1);
EXPECT_TRUE(Track::exists(session, track.getId()));
auto myTrack {Track::find(session, track.getId())};
ASSERT_TRUE(myTrack);
EXPECT_EQ(myTrack->getId(), track.getId());
}
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()) };
ASSERT_TRUE(myTrack);
EXPECT_EQ(myTrack->getId(), track.getId());
}
}
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());
EXPECT_FALSE(track1.get() == track2.get());
}
EXPECT_TRUE(track1.getId() != track2.getId());
EXPECT_TRUE(track1.get() != track2.get());
EXPECT_FALSE(track1.get() == track2.get());
}
}
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()};
track1.get().modify()->setName("MyTrack");
track2.get().modify()->setName("MyTrack%");
track3.get().modify()->setName("MyTrack%Foo");
track4.get().modify()->setName("%MyTrack");
track5.get().modify()->setName("Foo%MyTrack");
track6.get().modify()->setName("M_Track");
}
{
auto transaction{ session.createUniqueTransaction() };
track1.get().modify()->setName("MyTrack");
track2.get().modify()->setName("MyTrack%");
track3.get().modify()->setName("MyTrack%Foo");
track4.get().modify()->setName("%MyTrack");
track5.get().modify()->setName("Foo%MyTrack");
track6.get().modify()->setName("M_Track");
}
{
auto transaction {session.createSharedTransaction()};
{
auto transaction{ session.createSharedTransaction() };
{
const auto tracks {Track::find(session, Track::FindParameters {}.setKeywords({"Track"}))};
EXPECT_EQ(tracks.results.size(), 6);
}
{
const auto tracks {Track::find(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%"}))};
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"}))};
ASSERT_EQ(tracks.results.size(), 2);
EXPECT_EQ(tracks.results[0], track4.getId());
EXPECT_EQ(tracks.results[1], track5.getId());
}
}
{
const auto tracks{ Track::findIds(session, Track::FindParameters {}.setKeywords({"Track"})) };
EXPECT_EQ(tracks.results.size(), 6);
}
{
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::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::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());
}
}
}
TEST_F(DatabaseFixture, Track_date)
{
ScopedTrack track {session, "MyTrack"};
ScopedTrack track{ session, "MyTrack" };
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(track->getYear(), std::nullopt);
EXPECT_EQ(track->getOriginalYear(), std::nullopt);
}
{
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()};
EXPECT_EQ(track->getYear(), 1995);
EXPECT_EQ(track->getOriginalYear(), 1994);
}
{
auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(track->getYear(), 1995);
EXPECT_EQ(track->getOriginalYear(), 1994);
}
}
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()};
track.get().modify()->setLastWriteTime(dateTime);
}
{
auto transaction{ session.createUniqueTransaction() };
track.get().modify()->setLastWriteTime(dateTime);
}
{
auto transaction {session.createSharedTransaction()};
const auto tracks {Track::find(session, Track::FindParameters {})};
EXPECT_EQ(tracks.results.size(), 1);
}
{
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)))};
EXPECT_EQ(tracks.results.size(), 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)))};
EXPECT_EQ(tracks.results.size(), 0);
}
{
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
+61 -64
View File
@@ -30,89 +30,86 @@
namespace Recommendation
{
using namespace Database;
using namespace Database;
std::unique_ptr<IPlaylistGeneratorService>
createPlaylistGeneratorService(Db& db, Recommendation::IRecommendationService& recommendationService)
{
return std::make_unique<PlaylistGeneratorService>(db, 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}
{
_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>());
}
PlaylistGeneratorService::PlaylistGeneratorService(Db& db, Recommendation::IRecommendationService& 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
{
LMS_LOG(RECOMMENDATION, DEBUG) << "Requested to extend playlist by " << maxCount << " similar tracks";
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
// 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
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<TrackId> finalResult = startingTracks;
finalResult.reserve(startingTracks.size() + maxCount);
std::vector<float> scores;
for (std::size_t i {}; i < maxCount; ++i)
{
if (similarTracks.empty())
break;
std::vector<float> scores;
for (std::size_t i{}; i < maxCount; ++i)
{
if (similarTracks.empty())
break;
scores.resize(similarTracks.size(), {});
scores.resize(similarTracks.size(), {});
// select the similar track that has the best score
for (std::size_t trackIndex {}; trackIndex < similarTracks.size(); ++trackIndex)
{
using namespace Database::Debug;
// select the similar track that has the best score
for (std::size_t trackIndex{}; trackIndex < similarTracks.size(); ++trackIndex)
{
using namespace Database::Debug;
finalResult.push_back(similarTracks[trackIndex]);
finalResult.push_back(similarTracks[trackIndex]);
scores[trackIndex] = 0;
for (const auto& constraint : _constraints)
scores[trackIndex] += constraint->computeScore(finalResult, finalResult.size() - 1);
scores[trackIndex] = 0;
for (const auto& constraint : _constraints)
scores[trackIndex] += constraint->computeScore(finalResult, finalResult.size() - 1);
finalResult.pop_back();
finalResult.pop_back();
// early exit if we consider we found a track with no constraint violation (since similarTracks sorted from most to least similar)
if (scores[trackIndex] < 0.01)
break;
}
// early exit if we consider we found a track with no constraint violation (since similarTracks sorted from most to least similar)
if (scores[trackIndex] < 0.01)
break;
}
// 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))))};
// 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)))) };
finalResult.push_back(similarTracks[bestScoreIndex]);
similarTracks.erase(std::begin(similarTracks) + bestScoreIndex);
}
finalResult.push_back(similarTracks[bestScoreIndex]);
similarTracks.erase(std::begin(similarTracks) + bestScoreIndex);
}
// for now, just get some more similar tracks
return std::vector(std::cbegin(finalResult) + startingTracks.size(), std::cend(finalResult));
}
// for now, just get some more similar tracks
return std::vector(std::cbegin(finalResult) + startingTracks.size(), std::cend(finalResult));
}
TrackContainer
PlaylistGeneratorService::getTracksFromTrackList(Database::TrackListId tracklistId) const
{
TrackContainer tracks;
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);
Track::FindParameters params;
params.setTrackList(tracklistId);
params.setSortMethod(TrackSortMethod::TrackList);
params.setDistinct(false);
for (const TrackId trackId : Track::find(dbSession, params).results)
tracks.push_back(trackId);
for (const TrackId trackId : Track::findIds(dbSession, params).results)
tracks.push_back(trackId);
return tracks;
}
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
+495 -514
View File
File diff suppressed because it is too large Load Diff
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,11 +349,8 @@ 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,12 +96,8 @@ 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
+751 -783
View File
File diff suppressed because it is too large Load Diff
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
+113 -121
View File
@@ -29,153 +29,145 @@
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)
{
assert(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;
std::vector<Database::TrackId> res;
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
for (const Database::ArtistId artistId : artistsId)
{
Database::Track::FindParameters params;
params.setArtist(artistId);
params.setSortMethod(Database::TrackSortMethod::DateDescAndRelease);
params.setClusters(clusters);
params.setRange({0, maxTrackCount - res.size()});
for (const Database::ArtistId artistId : artistsId)
{
Database::Track::FindParameters params;
params.setArtist(artistId);
params.setSortMethod(Database::TrackSortMethod::DateDescAndRelease);
params.setClusters(clusters);
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));
res.reserve(res.size() + tracks.results.size());
res.insert(std::end(res), std::cbegin(tracks.results), std::cend(tracks.results));
if (res.size() == maxTrackCount)
break;
}
if (res.size() == maxTrackCount)
break;
}
return res;
}
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)
{
using namespace Database;
assert(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;
std::vector<TrackId> res;
auto transaction {session.createSharedTransaction()};
auto transaction{ session.createSharedTransaction() };
for (const ReleaseId releaseId : releasesId)
{
Database::Track::FindParameters params;
params.setRelease(releaseId);
params.setSortMethod(Database::TrackSortMethod::Release);
params.setClusters(clusters);
params.setRange({0, maxTrackCount - res.size()});
for (const ReleaseId releaseId : releasesId)
{
Database::Track::FindParameters params;
params.setRelease(releaseId);
params.setSortMethod(Database::TrackSortMethod::Release);
params.setClusters(clusters);
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));
res.reserve(res.size() + tracks.results.size());
res.insert(std::end(res), std::cbegin(tracks.results), std::cend(tracks.results));
if (res.size() == maxTrackCount)
break;
}
if (res.size() == maxTrackCount)
break;
}
return res;
}
return res;
}
static
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);
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.setSortMethod(TrackSortMethod::TrackList);
params.setDistinct(false);
Database::Track::FindParameters params;
params.setTrackList(trackListId);
params.setClusters(clusters);
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}
{
}
PlayQueueController::PlayQueueController(Filters& filters, PlayQueue& playQueue)
: _filters{ filters }
, _playQueue{ playQueue }
{
}
void
PlayQueueController::processCommand(Command command, const std::vector<Database::ArtistId>& artistIds)
{
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::ArtistId>& artistIds)
{
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)
{
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::ReleaseId>& releaseIds)
{
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)
{
// consider things are already filtered here, and _maxTrackCount honored playqueue side...
switch (command)
{
case Command::Play:
_playQueue.play(trackIds);
break;
case Command::PlayNext:
_playQueue.playNext(trackIds);
break;
case Command::PlayShuffled:
_playQueue.playShuffled(trackIds);
break;
case Command::PlayOrAddLast:
_playQueue.playOrAddLast(trackIds);
break;
}
}
void PlayQueueController::processCommand(Command command, const std::vector<Database::TrackId>& trackIds)
{
// consider things are already filtered here, and _maxTrackCount honored playqueue side...
switch (command)
{
case Command::Play:
_playQueue.play(trackIds);
break;
case Command::PlayNext:
_playQueue.playNext(trackIds);
break;
case Command::PlayShuffled:
_playQueue.playShuffled(trackIds);
break;
case Command::PlayOrAddLast:
_playQueue.playOrAddLast(trackIds);
break;
}
}
void
PlayQueueController::processCommand(Command command, Database::TrackListId trackListId)
{
const std::vector<Database::TrackId> tracks {getTrackListTracks(LmsApp->getDbSession(), trackListId, _filters.getClusterIds(), _maxTrackCountToEnqueue)};
processCommand(command, tracks);
}
void PlayQueueController::processCommand(Command command, Database::TrackListId trackListId)
{
const std::vector<Database::TrackId> tracks{ getTrackListTracks(LmsApp->getDbSession(), trackListId, _filters.getClusterIds(), _maxTrackCountToEnqueue) };
processCommand(command, tracks);
}
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)};
if (!track || !track->getRelease())
return;
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) };
if (!track || !track->getRelease())
return;
releaseId = track->getRelease()->getId();
}
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)};
if (itTrack == std::cend(tracks))
return;
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))};
_playQueue.playAtIndex(tracks, index);
}
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
+482 -495
View File
@@ -50,501 +50,488 @@
using namespace Database;
namespace UserInterface {
void
showReleaseInfoModal(Database::ReleaseId releaseId)
namespace UserInterface
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
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()};
releaseInfo->addFunction("tr", &Wt::WTemplate::Functions::tr);
if (auto primaryReleaseType {release->getPrimaryType()})
{
releaseInfo->setCondition("if-has-release-type", true);
releaseInfo->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(*primaryReleaseType, release->getSecondaryTypes()));
}
std::map<Wt::WString, std::set<ArtistId>> artistMap;
auto addArtists = [&](TrackArtistLinkType linkType, const char* type)
{
Artist::FindParameters params;
params.setRelease(releaseId);
params.setLinkType(linkType);
const auto artistIds {Artist::find(LmsApp->getDbSession(), params)};
if (artistIds.results.empty())
return;
Wt::WString typeStr {Wt::WString::trn(type, artistIds.results.size())};
for (ArtistId artistId : artistIds.results)
artistMap[typeStr].insert(artistId);
};
auto addPerformerArtists = [&]
{
TrackArtistLink::FindParameters params;
params.setRelease(releaseId);
params.setLinkType(TrackArtistLinkType::Performer);
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)};
if (!link)
continue;
artistMap[std::string {link->getSubType()}].insert(link->getArtist()->getId());
}
};
addArtists(TrackArtistLinkType::Composer, "Lms.Explore.Artists.linktype-composer");
addArtists(TrackArtistLinkType::Conductor, "Lms.Explore.Artists.linktype-conductor");
addArtists(TrackArtistLinkType::Lyricist, "Lms.Explore.Artists.linktype-lyricist");
addArtists(TrackArtistLinkType::Mixer, "Lms.Explore.Artists.linktype-mixer");
addArtists(TrackArtistLinkType::Remixer, "Lms.Explore.Artists.linktype-remixer");
addArtists(TrackArtistLinkType::Producer, "Lms.Explore.Artists.linktype-producer");
addPerformerArtists();
if (auto itRolelessPerformers {artistMap.find("")}; itRolelessPerformers != std::cend(artistMap))
{
Wt::WString performersStr {Wt::WString::trn("Lms.Explore.Artists.linktype-performer", itRolelessPerformers->second.size())};
artistMap[performersStr] = std::move(itRolelessPerformers->second);
artistMap.erase(itRolelessPerformers);
}
if (!artistMap.empty())
{
releaseInfo->setCondition("if-has-artist", true);
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"))};
artistsEntry->bindString("type", role);
artistsEntry->bindWidget("artist-container", std::move(artistContainer));
artistTable->addWidget(std::move(artistsEntry));
}
}
// TODO: save in DB and mean all this
for (TrackId trackId : 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())})
{
const std::optional<Av::StreamInfo> audioStream {audioFile->getBestStreamInfo()};
if (audioStream)
{
releaseInfo->setCondition("if-has-codec", true);
releaseInfo->bindString("codec", audioStream->codec);
if (audioStream->bitrate)
{
releaseInfo->setCondition("if-has-bitrate", true);
releaseInfo->bindString("bitrate", std::to_string(audioStream->bitrate / 1000) + " kbps");
break;
}
}
}
}
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}
{
addFunction("tr", &Wt::WTemplate::Functions::tr);
addFunction("id", &Wt::WTemplate::Functions::id);
wApp->internalPathChanged().connect(this, [this]
{
refreshView();
});
_filters.updated().connect([this]
{
_needForceRefresh = true;
refreshView();
});
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()
{
if (!wApp->internalPathMatches("/release/"))
return;
const auto releaseId {extractReleaseIdFromInternalPath()};
// consider everything is up to date is the same release is being rendered
if (!_needForceRefresh && releaseId && *releaseId == _releaseId)
return;
clear();
_releaseId = {};
_needForceRefresh = false;
if (!releaseId)
throw ReleaseNotFoundException {};
auto similarReleasesIds {Service<Recommendation::IRecommendationService>::get()->getSimilarReleases(*releaseId, 6)};
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
const Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), *releaseId)};
if (!release)
throw ReleaseNotFoundException {};
LmsApp->setTitle(release->getName());
_releaseId = *releaseId;
refreshCopyright(release);
refreshLinks(release);
refreshSimilarReleases(similarReleasesIds);
bindString("name", Wt::WString::fromUTF8(release->getName()), Wt::TextFormat::Plain);
Wt::WString year {ReleaseHelpers::buildReleaseYearString(release->getReleaseDate(), release->getOriginalReleaseDate())};
if (!year.empty())
{
setCondition("if-has-year", true);
bindString("year", year, Wt::TextFormat::Plain);
}
bindString("duration", Utils::durationToString(release->getDuration()), Wt::TextFormat::Plain);
refreshReleaseArtists(release);
bindWidget<Wt::WImage>("cover", Utils::createCover(release->getId(), CoverResource::Size::Large));
Wt::WContainerWidget* clusterContainers {bindNew<Wt::WContainerWidget>("clusters")};
{
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))};
entry->clicked().connect([=]
{
_filters.add(clusterId);
});
}
}
}
bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML)
->clicked().connect([=]
{
_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});
});
bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"), Wt::TextFormat::Plain)
->clicked().connect([=]
{
_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});
});
bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
->setLink(Wt::WLink {std::make_unique<DownloadReleaseResource>(_releaseId)});
bindNew<Wt::WPushButton>("release-info", Wt::WString::tr("Lms.Explore.release-info"))
->clicked().connect([=]
{
showReleaseInfoModal(_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"))};
starBtn->clicked().connect([=]
{
if (isStarred())
{
Service<Feedback::IFeedbackService>::get()->unstar(LmsApp->getUserId(), _releaseId);
starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
}
else
{
Service<Feedback::IFeedbackService>::get()->star(LmsApp->getUserId(), _releaseId);
starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
}
});
}
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)};
// Expect to be called in asc order
std::map<std::size_t, Wt::WContainerWidget*> trackContainers;
auto getOrAddDiscContainer = [&](std::size_t discNumber, const std::string& discSubtitle) -> Wt::WContainerWidget*
{
{
auto it = trackContainers.find(discNumber);
if (it != std::cend(trackContainers))
return it->second;
}
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")};
trackContainers[discNumber] = tracksContainer;
return tracksContainer;
};
Wt::WContainerWidget* noDiscTracksContainer{};
auto getOrAddNoDiscContainer = [&]
{
if (noDiscTracksContainer)
return noDiscTracksContainer;
Wt::WTemplate* disc {rootContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Release.template.entry-nodisc"))};
noDiscTracksContainer = disc->bindNew<Wt::WContainerWidget>("tracks");
return noDiscTracksContainer;
};
Database::Track::FindParameters params;
params.setRelease(_releaseId);
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)
{
const Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), trackId)};
const auto discNumber {track->getDiscNumber()};
Wt::WContainerWidget* container;
if (isReleaseMultiDisc && discNumber)
container = getOrAddDiscContainer(*discNumber, track->getDiscSubtitle());
else
container = getOrAddNoDiscContainer();
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})};
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));
}
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)};
playBtn->clicked().connect([=]
{
_playQueueController.playTrackInRelease(trackId);
});
{
entry->bindNew<Wt::WPushButton>("more-btn", Wt::WString::tr("Lms.template.more-btn"), Wt::TextFormat::XHTML);
entry->bindNew<Wt::WPushButton>("play", Wt::WString::tr("Lms.Explore.play"))
->clicked().connect([=]
{
_playQueueController.playTrackInRelease(trackId);
});
entry->bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"))
->clicked().connect([=]
{
_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});
});
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"))};
starBtn->clicked().connect([=]
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
if (isStarred())
{
Service<Feedback::IFeedbackService>::get()->unstar(LmsApp->getUserId(), trackId);
starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
}
else
{
Service<Feedback::IFeedbackService>::get()->star(LmsApp->getUserId(), trackId);
starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
}
});
entry->bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
->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); });
}
entry->bindString("duration", Utils::durationToString(track->getDuration()), Wt::TextFormat::Plain);
LmsApp->getMediaPlayer().trackLoaded.connect(entry, [=] (TrackId loadedTrackId)
{
entry->toggleStyleClass("Lms-entry-playing", loadedTrackId == trackId);
});
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)
{
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()};
if (!copyright && !copyrightURL)
return;
setCondition("if-has-copyright", true);
std::string copyrightText {copyright ? *copyright : ""};
if (copyrightText.empty() && copyrightURL)
copyrightText = *copyrightURL;
if (copyrightURL)
{
Wt::WLink link {*copyrightURL};
link.setTarget(Wt::LinkTarget::NewWindow);
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()};
if (mbid)
{
setCondition("if-has-mbid", true);
bindString("mbid-link", std::string {"https://musicbrainz.org/release/"} + std::string {mbid->getAsString()});
}
}
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")};
for (const ReleaseId id : similarReleasesId)
{
const Database::Release::pointer similarRelease {Database::Release::find(LmsApp->getDbSession(), id)};
if (!similarRelease)
continue;
similarReleasesContainer->addWidget(ReleaseListHelpers::createEntry(similarRelease));
}
}
namespace
{
void showReleaseInfoModal(Database::ReleaseId releaseId)
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
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() };
releaseInfo->addFunction("tr", &Wt::WTemplate::Functions::tr);
if (auto primaryReleaseType{ release->getPrimaryType() })
{
releaseInfo->setCondition("if-has-release-type", true);
releaseInfo->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(*primaryReleaseType, release->getSecondaryTypes()));
}
std::map<Wt::WString, std::set<ArtistId>> artistMap;
auto addArtists = [&](TrackArtistLinkType linkType, const char* type)
{
Artist::FindParameters params;
params.setRelease(releaseId);
params.setLinkType(linkType);
const auto artistIds{ Artist::find(LmsApp->getDbSession(), params) };
if (artistIds.results.empty())
return;
Wt::WString typeStr{ Wt::WString::trn(type, artistIds.results.size()) };
for (ArtistId artistId : artistIds.results)
artistMap[typeStr].insert(artistId);
};
auto addPerformerArtists = [&]
{
TrackArtistLink::FindParameters params;
params.setRelease(releaseId);
params.setLinkType(TrackArtistLinkType::Performer);
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) };
if (!link)
continue;
artistMap[std::string{ link->getSubType() }].insert(link->getArtist()->getId());
}
};
addArtists(TrackArtistLinkType::Composer, "Lms.Explore.Artists.linktype-composer");
addArtists(TrackArtistLinkType::Conductor, "Lms.Explore.Artists.linktype-conductor");
addArtists(TrackArtistLinkType::Lyricist, "Lms.Explore.Artists.linktype-lyricist");
addArtists(TrackArtistLinkType::Mixer, "Lms.Explore.Artists.linktype-mixer");
addArtists(TrackArtistLinkType::Remixer, "Lms.Explore.Artists.linktype-remixer");
addArtists(TrackArtistLinkType::Producer, "Lms.Explore.Artists.linktype-producer");
addPerformerArtists();
if (auto itRolelessPerformers{ artistMap.find("") }; itRolelessPerformers != std::cend(artistMap))
{
Wt::WString performersStr{ Wt::WString::trn("Lms.Explore.Artists.linktype-performer", itRolelessPerformers->second.size()) };
artistMap[performersStr] = std::move(itRolelessPerformers->second);
artistMap.erase(itRolelessPerformers);
}
if (!artistMap.empty())
{
releaseInfo->setCondition("if-has-artist", true);
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")) };
artistsEntry->bindString("type", role);
artistsEntry->bindWidget("artist-container", std::move(artistContainer));
artistTable->addWidget(std::move(artistsEntry));
}
}
// TODO: save in DB and mean all this
for (const Track::pointer& track : Track::find(LmsApp->getDbSession(), Track::FindParameters{}.setRelease(releaseId).setRange(Range{ 0, 1 })).results)
{
if (const auto audioFile{ Av::parseAudioFile(track->getPath()) })
{
const std::optional<Av::StreamInfo> audioStream{ audioFile->getBestStreamInfo() };
if (audioStream)
{
releaseInfo->setCondition("if-has-codec", true);
releaseInfo->bindString("codec", audioStream->codec);
if (audioStream->bitrate)
{
releaseInfo->setCondition("if-has-bitrate", true);
releaseInfo->bindString("bitrate", std::to_string(audioStream->bitrate / 1000) + " kbps");
break;
}
}
}
}
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));
}
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);
wApp->internalPathChanged().connect(this, [this]
{
refreshView();
});
_filters.updated().connect([this]
{
_needForceRefresh = true;
refreshView();
});
refreshView();
}
void Release::refreshView()
{
if (!wApp->internalPathMatches("/release/"))
return;
const auto releaseId{ extractReleaseIdFromInternalPath() };
// consider everything is up to date is the same release is being rendered
if (!_needForceRefresh && releaseId && *releaseId == _releaseId)
return;
clear();
_releaseId = {};
_needForceRefresh = false;
if (!releaseId)
throw ReleaseNotFoundException{};
auto similarReleasesIds{ Service<Recommendation::IRecommendationService>::get()->getSimilarReleases(*releaseId, 6) };
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), *releaseId) };
if (!release)
throw ReleaseNotFoundException{};
LmsApp->setTitle(release->getName());
_releaseId = *releaseId;
refreshCopyright(release);
refreshLinks(release);
refreshSimilarReleases(similarReleasesIds);
bindString("name", Wt::WString::fromUTF8(release->getName()), Wt::TextFormat::Plain);
Wt::WString year{ ReleaseHelpers::buildReleaseYearString(release->getReleaseDate(), release->getOriginalReleaseDate()) };
if (!year.empty())
{
setCondition("if-has-year", true);
bindString("year", year, Wt::TextFormat::Plain);
}
bindString("duration", Utils::durationToString(release->getDuration()), Wt::TextFormat::Plain);
refreshReleaseArtists(release);
bindWidget<Wt::WImage>("cover", Utils::createCover(release->getId(), CoverResource::Size::Large));
Wt::WContainerWidget* clusterContainers{ bindNew<Wt::WContainerWidget>("clusters") };
{
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)) };
entry->clicked().connect([=]
{
_filters.add(clusterId);
});
}
}
}
bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML)
->clicked().connect([=]
{
_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 });
});
bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"), Wt::TextFormat::Plain)
->clicked().connect([=]
{
_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 });
});
bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
->setLink(Wt::WLink{ std::make_unique<DownloadReleaseResource>(_releaseId) });
bindNew<Wt::WPushButton>("release-info", Wt::WString::tr("Lms.Explore.release-info"))
->clicked().connect([=]
{
showReleaseInfoModal(_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")) };
starBtn->clicked().connect([=]
{
if (isStarred())
{
Service<Feedback::IFeedbackService>::get()->unstar(LmsApp->getUserId(), _releaseId);
starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
}
else
{
Service<Feedback::IFeedbackService>::get()->star(LmsApp->getUserId(), _releaseId);
starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
}
});
}
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) };
// Expect to be called in asc order
std::map<std::size_t, Wt::WContainerWidget*> trackContainers;
auto getOrAddDiscContainer = [&](std::size_t discNumber, const std::string& discSubtitle) -> Wt::WContainerWidget*
{
{
auto it = trackContainers.find(discNumber);
if (it != std::cend(trackContainers))
return it->second;
}
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") };
trackContainers[discNumber] = tracksContainer;
return tracksContainer;
};
Wt::WContainerWidget* noDiscTracksContainer{};
auto getOrAddNoDiscContainer = [&]
{
if (noDiscTracksContainer)
return noDiscTracksContainer;
Wt::WTemplate* disc{ rootContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Release.template.entry-nodisc")) };
noDiscTracksContainer = disc->bindNew<Wt::WContainerWidget>("tracks");
return noDiscTracksContainer;
};
Database::Track::FindParameters params;
params.setRelease(_releaseId);
params.setSortMethod(Database::TrackSortMethod::Release);
params.setClusters(_filters.getClusterIds());
for (const Database::Track::pointer& track : Database::Track::find(LmsApp->getDbSession(), params).results)
{
const Database::TrackId trackId{ track->getId() };
const auto discNumber{ track->getDiscNumber() };
Wt::WContainerWidget* container;
if (isReleaseMultiDisc && discNumber)
container = getOrAddDiscContainer(*discNumber, track->getDiscSubtitle());
else
container = getOrAddNoDiscContainer();
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}) };
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));
}
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) };
playBtn->clicked().connect([=]
{
_playQueueController.playTrackInRelease(trackId);
});
{
entry->bindNew<Wt::WPushButton>("more-btn", Wt::WString::tr("Lms.template.more-btn"), Wt::TextFormat::XHTML);
entry->bindNew<Wt::WPushButton>("play", Wt::WString::tr("Lms.Explore.play"))
->clicked().connect([=]
{
_playQueueController.playTrackInRelease(trackId);
});
entry->bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"))
->clicked().connect([=]
{
_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 });
});
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")) };
starBtn->clicked().connect([=]
{
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
if (isStarred())
{
Service<Feedback::IFeedbackService>::get()->unstar(LmsApp->getUserId(), trackId);
starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
}
else
{
Service<Feedback::IFeedbackService>::get()->star(LmsApp->getUserId(), trackId);
starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
}
});
entry->bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
->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); });
}
entry->bindString("duration", Utils::durationToString(track->getDuration()), Wt::TextFormat::Plain);
LmsApp->getMediaPlayer().trackLoaded.connect(entry, [=](TrackId loadedTrackId)
{
entry->toggleStyleClass("Lms-entry-playing", loadedTrackId == trackId);
});
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)
{
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() };
if (!copyright && !copyrightURL)
return;
setCondition("if-has-copyright", true);
std::string copyrightText{ copyright ? *copyright : "" };
if (copyrightText.empty() && copyrightURL)
copyrightText = *copyrightURL;
if (copyrightURL)
{
Wt::WLink link{ *copyrightURL };
link.setTarget(Wt::LinkTarget::NewWindow);
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() };
if (mbid)
{
setCondition("if-has-mbid", true);
bindString("mbid-link", std::string{ "https://musicbrainz.org/release/" } + std::string{ mbid->getAsString() });
}
}
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") };
for (const ReleaseId id : similarReleasesId)
{
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
+80 -83
View File
@@ -33,105 +33,102 @@
namespace UserInterface
{
using namespace Database;
using namespace Database;
RangeResults<TrackId>
TrackCollector::get(Range range)
{
Feedback::IFeedbackService& feedbackService{*Service<Feedback::IFeedbackService>::get()};
Scrobbling::IScrobblingService& scrobblingService {*Service<Scrobbling::IScrobblingService>::get()};
RangeResults<TrackId> tracks;
range = getActualRange(range);
if (range.size == 0)
return tracks;
RangeResults<TrackId> TrackCollector::get(Range range)
{
Feedback::IFeedbackService& feedbackService{ *Service<Feedback::IFeedbackService>::get() };
Scrobbling::IScrobblingService& scrobblingService{ *Service<Scrobbling::IScrobblingService>::get() };
switch (getMode())
{
case Mode::Random:
tracks = getRandomTracks(range);
break;
RangeResults<TrackId> tracks;
range = getActualRange(range);
if (range.size == 0)
return tracks;
case Mode::Starred:
tracks = feedbackService.getStarredTracks(LmsApp->getUserId(), getFilters().getClusterIds(), range);
break;
switch (getMode())
{
case Mode::Random:
tracks = getRandomTracks(range);
break;
case TrackCollector::Mode::RecentlyPlayed:
tracks = scrobblingService.getRecentTracks(LmsApp->getUserId(), getFilters().getClusterIds(), range);
break;
case Mode::Starred:
tracks = feedbackService.getStarredTracks(LmsApp->getUserId(), getFilters().getClusterIds(), range);
break;
case Mode::MostPlayed:
tracks = scrobblingService.getTopTracks(LmsApp->getUserId(), getFilters().getClusterIds(), range);
break;
case TrackCollector::Mode::RecentlyPlayed:
tracks = scrobblingService.getRecentTracks(LmsApp->getUserId(), getFilters().getClusterIds(), range);
break;
case Mode::RecentlyAdded:
{
Track::FindParameters params;
params.setClusters(getFilters().getClusterIds());
params.setSortMethod(TrackSortMethod::LastWritten);
params.setRange(range);
case Mode::MostPlayed:
tracks = scrobblingService.getTopTracks(LmsApp->getUserId(), getFilters().getClusterIds(), range);
break;
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
tracks = Track::find(LmsApp->getDbSession(), params);
}
break;
}
case Mode::RecentlyAdded:
{
Track::FindParameters params;
params.setClusters(getFilters().getClusterIds());
params.setSortMethod(TrackSortMethod::LastWritten);
params.setRange(range);
case Mode::Search:
{
Track::FindParameters params;
params.setClusters(getFilters().getClusterIds());
params.setKeywords(getSearchKeywords());
params.setRange(range);
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
tracks = Track::findIds(LmsApp->getDbSession(), params);
}
break;
}
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
tracks = Track::find(LmsApp->getDbSession(), params);
}
break;
}
case Mode::Search:
{
Track::FindParameters params;
params.setClusters(getFilters().getClusterIds());
params.setKeywords(getSearchKeywords());
params.setRange(range);
case Mode::All:
{
Track::FindParameters params;
params.setClusters(getFilters().getClusterIds());
params.setRange(range);
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
tracks = Track::findIds(LmsApp->getDbSession(), params);
}
break;
}
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
tracks = Track::find(LmsApp->getDbSession(), params);
}
break;
}
}
case Mode::All:
{
Track::FindParameters params;
params.setClusters(getFilters().getClusterIds());
params.setRange(range);
if (range.offset + range.size == getMaxCount())
tracks.moreResults = false;
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
tracks = Track::findIds(LmsApp->getDbSession(), params);
}
break;
}
}
return tracks;
}
if (range.offset + range.size == getMaxCount())
tracks.moreResults = false;
RangeResults<TrackId>
TrackCollector::getRandomTracks(Range range)
{
assert(getMode() == Mode::Random);
return tracks;
}
if (!_randomTracks)
{
Track::FindParameters params;
params.setClusters(getFilters().getClusterIds());
params.setSortMethod(TrackSortMethod::Random);
params.setRange({0, getMaxCount()});
RangeResults<TrackId> TrackCollector::getRandomTracks(Range range)
{
assert(getMode() == Mode::Random);
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
_randomTracks = Track::find(LmsApp->getDbSession(), params);
}
}
if (!_randomTracks)
{
Track::FindParameters params;
params.setClusters(getFilters().getClusterIds());
params.setSortMethod(TrackSortMethod::Random);
params.setRange({ 0, getMaxCount() });
return _randomTracks->getSubRange(range);
}
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
_randomTracks = Track::findIds(LmsApp->getDbSession(), params);
}
}
return _randomTracks->getSubRange(range);
}
} // ns UserInterface
src/lms/ui/explore/TrackListView.cpp
+124 -132
View File
@@ -39,166 +39,158 @@
#include "ModalManager.hpp"
#include "Utils.hpp"
using namespace Database;
namespace
{
static
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}
{
addFunction("tr", &Wt::WTemplate::Functions::tr);
addFunction("id", &Wt::WTemplate::Functions::id);
using namespace Database;
wApp->internalPathChanged().connect(this, [this]
{
refreshView();
});
namespace
{
std::optional<TrackListId> extractTrackListIdFromInternalPath()
{
return StringUtils::readAs<TrackListId::ValueType>(wApp->internalPathNextPart("/tracklist/"));
}
}
_filters.updated().connect([this]
{
refreshView();
});
TrackList::TrackList(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);
refreshView();
}
wApp->internalPathChanged().connect(this, [this]
{
refreshView();
});
void
TrackList::refreshView()
{
if (!wApp->internalPathMatches("/tracklist/"))
return;
_filters.updated().connect([this]
{
refreshView();
});
const std::optional<TrackListId> trackListId {extractTrackListIdFromInternalPath()};
if (!trackListId)
throw TrackListNotFoundException {};
refreshView();
}
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
void TrackList::refreshView()
{
if (!wApp->internalPathMatches("/tracklist/"))
return;
const Database::TrackList::pointer trackList {Database::TrackList::find(LmsApp->getDbSession(), *trackListId)};
if (!trackList)
throw TrackListNotFoundException {};
const std::optional<TrackListId> trackListId{ extractTrackListIdFromInternalPath() };
if (!trackListId)
throw TrackListNotFoundException{};
LmsApp->setTitle(std::string {trackList->getName()});
_trackListId = *trackListId;
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
clear();
const Database::TrackList::pointer trackList{ Database::TrackList::find(LmsApp->getDbSession(), *trackListId) };
if (!trackList)
throw TrackListNotFoundException{};
bindString("name", std::string {trackList->getName()}, Wt::TextFormat::Plain);
bindString("duration", Utils::durationToString(trackList->getDuration()));
const auto trackCount {trackList->getCount()};
bindString("track-count", Wt::WString::trn("Lms.track-count", trackCount).arg(trackCount));
LmsApp->setTitle(std::string{ trackList->getName() });
_trackListId = *trackListId;
Wt::WContainerWidget* clusterContainers {bindNew<Wt::WContainerWidget>("clusters")};
{
const auto clusterTypes {ScanSettings::get(LmsApp->getDbSession())->getClusterTypes()};
const auto clusterGroups {trackList->getClusterGroups(clusterTypes, 3)};
clear();
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))};
entry->clicked().connect([=]
{
_filters.add(clusterId);
});
}
}
}
bindString("name", std::string{ trackList->getName() }, Wt::TextFormat::Plain);
bindString("duration", Utils::durationToString(trackList->getDuration()));
const auto trackCount{ trackList->getCount() };
bindString("track-count", Wt::WString::trn("Lms.track-count", trackCount).arg(trackCount));
bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML)
->clicked().connect([=]
{
_playQueueController.processCommand(PlayQueueController::Command::Play, *trackListId);
});
Wt::WContainerWidget* clusterContainers{ bindNew<Wt::WContainerWidget>("clusters") };
{
const auto clusterTypes{ ScanSettings::get(LmsApp->getDbSession())->getClusterTypes() };
const auto clusterGroups{ trackList->getClusterGroups(clusterTypes, 3) };
bindNew<Wt::WPushButton>("play-shuffled", Wt::WString::tr("Lms.Explore.play-shuffled"), Wt::TextFormat::Plain)
->clicked().connect([=]
{
_playQueueController.processCommand(PlayQueueController::Command::PlayShuffled, *trackListId);
});
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)) };
entry->clicked().connect([=]
{
_filters.add(clusterId);
});
}
}
}
bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"), Wt::TextFormat::Plain)
->clicked().connect([=]
{
_playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, *trackListId);
});
bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML)
->clicked().connect([=]
{
_playQueueController.processCommand(PlayQueueController::Command::Play, *trackListId);
});
bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
->setLink(Wt::WLink {std::make_unique<DownloadTrackListResource>(*trackListId)});
bindNew<Wt::WPushButton>("play-shuffled", Wt::WString::tr("Lms.Explore.play-shuffled"), Wt::TextFormat::Plain)
->clicked().connect([=]
{
_playQueueController.processCommand(PlayQueueController::Command::PlayShuffled, *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"))};
modal->addFunction("tr", &Wt::WTemplate::Functions::tr);
Wt::WWidget* modalPtr {modal.get()};
bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"), Wt::TextFormat::Plain)
->clicked().connect([=]
{
_playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, *trackListId);
});
auto* delBtn {modal->bindNew<Wt::WPushButton>("del-btn", Wt::WString::tr("Lms.delete"))};
delBtn->clicked().connect([=]
{
{
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
->setLink(Wt::WLink{ std::make_unique<DownloadTrackListResource>(*trackListId) });
Database::TrackList::pointer trackList {Database::TrackList::find(LmsApp->getDbSession(), *trackListId)};
if (trackList)
trackList.remove();
}
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")) };
modal->addFunction("tr", &Wt::WTemplate::Functions::tr);
Wt::WWidget* modalPtr{ modal.get() };
clear();
trackListDeleted.emit(*trackListId);
LmsApp->setInternalPath("/tracklists", true);
auto* delBtn{ modal->bindNew<Wt::WPushButton>("del-btn", Wt::WString::tr("Lms.delete")) };
delBtn->clicked().connect([=]
{
{
auto transaction{ LmsApp->getDbSession().createUniqueTransaction() };
LmsApp->getModalManager().dispose(modalPtr);
});
Database::TrackList::pointer trackList{ Database::TrackList::find(LmsApp->getDbSession(), *trackListId) };
if (trackList)
trackList.remove();
}
auto* cancelBtn {modal->bindNew<Wt::WPushButton>("cancel-btn", Wt::WString::tr("Lms.cancel"))};
cancelBtn->clicked().connect([=]
{
LmsApp->getModalManager().dispose(modalPtr);
});
clear();
trackListDeleted.emit(*trackListId);
LmsApp->setInternalPath("/tracklists", true);
LmsApp->getModalManager().show(std::move(modal));
});
LmsApp->getModalManager().dispose(modalPtr);
});
_container = bindNew<InfiniteScrollingContainer>("tracks", Wt::WString::tr("Lms.Explore.TrackList.template.entry-container"));
_container->onRequestElements.connect([this]
{
addSome();
});
}
auto* cancelBtn{ modal->bindNew<Wt::WPushButton>("cancel-btn", Wt::WString::tr("Lms.cancel")) };
cancelBtn->clicked().connect([=]
{
LmsApp->getModalManager().dispose(modalPtr);
});
void
TrackList::addSome()
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
LmsApp->getModalManager().show(std::move(modal));
});
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.setDistinct(false);
_container = bindNew<InfiniteScrollingContainer>("tracks", Wt::WString::tr("Lms.Explore.TrackList.template.entry-container"));
_container->onRequestElements.connect([this]
{
addSome();
});
}
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)})
_container->add(TrackListHelpers::createEntry(track, _playQueueController, _filters));
}
}
void TrackList::addSome()
{
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.setDistinct(false);
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
+165 -198
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,243 +34,214 @@
#define LOG(level) LMS_LOG(UI, level) << "Download resource: "
namespace UserInterface {
DownloadResource::~DownloadResource()
namespace UserInterface
{
beingDeleted();
}
void
DownloadResource::handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response)
{
try
{
std::shared_ptr<Zip::IZipper> zipper;
DownloadResource::~DownloadResource()
{
beingDeleted();
}
// First, see if this request is for a continuation
if (Wt::Http::ResponseContinuation *continuation {request.continuation()})
zipper = Wt::cpp17::any_cast<std::shared_ptr<Zip::IZipper>>(continuation->data());
else
{
zipper = createZipper();
response.setMimeType("application/zip");
}
void DownloadResource::handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response)
{
try
{
std::shared_ptr<Zip::IZipper> zipper;
zipper->writeSome(response.out());
if (!zipper->isComplete())
{
auto* continuation {response.createContinuation()};
continuation->setData(zipper);
}
}
catch (Zip::Exception& exception)
{
LOG(ERROR) << "Zipper exception: " << exception.what();
}
}
// First, see if this request is for a continuation
if (Wt::Http::ResponseContinuation * continuation{ request.continuation() })
zipper = Wt::cpp17::any_cast<std::shared_ptr<Zip::IZipper>>(continuation->data());
else
{
zipper = createZipper();
response.setMimeType("application/zip");
}
static
std::string
getArtistPathName(Database::Artist::pointer artist)
{
return StringUtils::replaceInString(artist->getName(), "/", "_");
}
zipper->writeSome(response.out());
if (!zipper->isComplete())
{
auto* continuation{ response.createContinuation() };
continuation->setData(zipper);
}
}
catch (Zip::Exception& exception)
{
LOG(ERROR) << "Zipper exception: " << exception.what();
}
}
static
std::string
getReleaseArtistPathName(Database::Release::pointer release)
{
std::string releaseArtistName;
namespace
{
std::string getArtistPathName(Database::Artist::pointer artist)
{
return StringUtils::replaceInString(artist->getName(), "/", "_");
}
std::vector<Database::ObjectPtr<Database::Artist>> artists;
std::string getReleaseArtistPathName(Database::Release::pointer release)
{
std::string releaseArtistName;
artists = release->getReleaseArtists();
if (artists.empty())
artists = release->getArtists();
std::vector<Database::ObjectPtr<Database::Artist>> artists;
if (artists.size() > 1)
releaseArtistName = Wt::WString::tr("Lms.Explore.various-artists").toUTF8();
else if (artists.size() == 1)
releaseArtistName = artists.front()->getName();
artists = release->getReleaseArtists();
if (artists.empty())
artists = release->getArtists();
releaseArtistName = StringUtils::replaceInString(releaseArtistName, "/", "_");
if (artists.size() > 1)
releaseArtistName = Wt::WString::tr("Lms.Explore.various-artists").toUTF8();
else if (artists.size() == 1)
releaseArtistName = artists.front()->getName();
return releaseArtistName;
}
releaseArtistName = StringUtils::replaceInString(releaseArtistName, "/", "_");
static
std::string
getReleasePathName(Database::Release::pointer release)
{
std::string releaseName;
return releaseArtistName;
}
if (const Wt::WDate releaseDate {release->getReleaseDate()}; releaseDate.isValid())
releaseName += std::to_string(releaseDate.year()) + " - ";
releaseName += StringUtils::replaceInString(release->getName(), "/", "_");
std::string getReleasePathName(Database::Release::pointer release)
{
std::string releaseName;
return releaseName;
}
if (const Wt::WDate releaseDate{ release->getReleaseDate() }; releaseDate.isValid())
releaseName += std::to_string(releaseDate.year()) + " - ";
releaseName += StringUtils::replaceInString(release->getName(), "/", "_");
namespace details
{
static
std::string
getTrackPathName(Database::Track::pointer track)
{
std::ostringstream fileName;
return releaseName;
}
}
if (auto discNumber {track->getDiscNumber()})
fileName << *discNumber << ".";
if (auto trackNumber {track->getTrackNumber()})
fileName << std::setw(2) << std::setfill('0') << *trackNumber << " - ";
namespace details
{
std::string getTrackPathName(Database::Track::pointer track)
{
std::ostringstream fileName;
fileName << StringUtils::replaceInString(track->getName(), "/", "_") << track->getPath().filename().extension().string();
if (auto discNumber{ track->getDiscNumber() })
fileName << *discNumber << ".";
if (auto trackNumber{ track->getTrackNumber() })
fileName << std::setw(2) << std::setfill('0') << *trackNumber << " - ";
return fileName.str();
}
fileName << StringUtils::replaceInString(track->getName(), "/", "_") << track->getPath().filename().extension().string();
static
std::string
getTrackListPathName(Database::TrackList::pointer trackList)
{
return StringUtils::replaceInString(trackList->getName(), "/", "_");
}
return fileName.str();
}
static
std::unique_ptr<Zip::IZipper>
createZipper(const std::vector<Database::Track::pointer>& tracks)
{
if (tracks.empty())
return {};
std::string getTrackListPathName(Database::TrackList::pointer trackList)
{
return StringUtils::replaceInString(trackList->getName(), "/", "_");
}
Zip::EntryContainer files;
for (const Database::Track::pointer& track : tracks)
{
std::string releaseName;
std::string releaseArtistName;
if (auto release {track->getRelease()})
{
releaseName = getReleasePathName(release);
releaseArtistName = getReleaseArtistPathName(release);
}
std::unique_ptr<Zip::IZipper> createZipper(const std::vector<Database::Track::pointer>& tracks)
{
if (tracks.empty())
return {};
std::string fileName;
if (!releaseArtistName.empty())
fileName += releaseArtistName + "/";
if (!releaseName.empty())
fileName += releaseName + "/";
fileName += getTrackPathName(track);
Zip::EntryContainer files;
for (const Database::Track::pointer& track : tracks)
{
std::string releaseName;
std::string releaseArtistName;
if (auto release{ track->getRelease() })
{
releaseName = getReleasePathName(release);
releaseArtistName = getReleaseArtistPathName(release);
}
files.emplace_back(Zip::Entry {fileName, track->getPath()});
}
std::string fileName;
if (!releaseArtistName.empty())
fileName += releaseArtistName + "/";
if (!releaseName.empty())
fileName += releaseName + "/";
fileName += getTrackPathName(track);
return Zip::createArchiveZipper(files);
}
}
files.emplace_back(Zip::Entry{ fileName, track->getPath() });
}
DownloadArtistResource::DownloadArtistResource(Database::ArtistId artistId)
: _artistId {artistId}
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
return Zip::createArchiveZipper(files);
}
}
Database::Artist::pointer artist {Database::Artist::find(LmsApp->getDbSession(), artistId)};
if (artist)
suggestFileName(getArtistPathName(artist) + ".zip");
}
DownloadArtistResource::DownloadArtistResource(Database::ArtistId artistId)
: _artistId{ artistId }
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
std::unique_ptr<Zip::IZipper>
DownloadArtistResource::createZipper()
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
Database::Artist::pointer artist{ Database::Artist::find(LmsApp->getDbSession(), artistId) };
if (artist)
suggestFileName(getArtistPathName(artist) + ".zip");
}
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());
std::unique_ptr<Zip::IZipper> DownloadArtistResource::createZipper()
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
for (const Database::TrackId trackId : trackResults.results)
tracks.push_back(Database::Track::find(LmsApp->getDbSession(), trackId));
const auto trackResults{ Database::Track::find(LmsApp->getDbSession(), Database::Track::FindParameters {}.setArtist(_artistId).setSortMethod(Database::TrackSortMethod::DateDescAndRelease)) };
return details::createZipper(trackResults.results);
}
return details::createZipper(tracks);
}
DownloadReleaseResource::DownloadReleaseResource(Database::ReleaseId releaseId)
: _releaseId{ releaseId }
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
DownloadReleaseResource::DownloadReleaseResource(Database::ReleaseId releaseId)
: _releaseId {releaseId}
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), releaseId)};
if (release)
suggestFileName(getReleasePathName(release) + ".zip");
}
Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), releaseId) };
if (release)
suggestFileName(getReleasePathName(release) + ".zip");
}
std::unique_ptr<Zip::IZipper>
DownloadReleaseResource::createZipper()
{
using namespace Database;
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);
}
Database::Track::pointer track{ Database::Track::find(LmsApp->getDbSession(), trackId) };
if (track)
suggestFileName(details::getTrackPathName(track) + ".zip");
}
DownloadTrackResource::DownloadTrackResource(Database::TrackId trackId)
: _trackId {trackId}
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
std::unique_ptr<Zip::IZipper> DownloadTrackResource::createZipper()
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), trackId)};
if (track)
suggestFileName(details::getTrackPathName(track) + ".zip");
}
const Database::Track::pointer track{ Database::Track::find(LmsApp->getDbSession(), _trackId) };
if (!track)
{
LOG(DEBUG) << "Cannot find track";
return {};
}
std::unique_ptr<Zip::IZipper>
DownloadTrackResource::createZipper()
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
return details::createZipper({ track });
}
const Database::Track::pointer track {Database::Track::find(LmsApp->getDbSession(), _trackId)};
if (!track)
{
LOG(DEBUG) << "Cannot find track";
return {};
}
DownloadTrackListResource::DownloadTrackListResource(Database::TrackListId trackListId)
: _trackListId{ trackListId }
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
return details::createZipper({track});
}
const Database::TrackList::pointer trackList{ Database::TrackList::find(LmsApp->getDbSession(), trackListId) };
if (trackList)
suggestFileName(details::getTrackListPathName(trackList) + ".zip");
}
DownloadTrackListResource::DownloadTrackListResource(Database::TrackListId trackListId)
: _trackListId {trackListId}
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
std::unique_ptr<Zip::IZipper> DownloadTrackListResource::createZipper()
{
using namespace Database;
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
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()
{
using namespace Database;
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);
}
Track::FindParameters params;
params.setTrackList(_trackListId);
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