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

Scan tracker: now handle releases and artists

Browse Source
This commit is contained in:
emeric
2024-03-23 15:55:29 +01:00
parent 5bfd31ff8a
commit 1630b7cb6f
8 changed files with 514 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/database/impl/Artist.cpp
+31 -5
View File
@@ -40,6 +40,7 @@ namespace lms::db
{
session.checkReadTransaction();
// TODO remove distinct and use group by
auto query{ session.getDboSession().query<ResultType>("SELECT DISTINCT " + std::string{ itemToSelect } + " FROM artist a") };
if (params.sortMethod == ArtistSortMethod::LastWritten
|| params.writtenAfter.isValid()
@@ -64,13 +65,13 @@ namespace lms::db
std::vector<std::string> clauses;
std::vector<std::string> sortClauses;
for (std::string_view keyword : params.keywords)
for (const std::string_view keyword : params.keywords)
{
clauses.push_back("a.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
query.bind("%" + utils::escapeLikeKeyword(keyword) + "%");
}
for (std::string_view keyword : params.keywords)
for (const std::string_view keyword : params.keywords)
{
sortClauses.push_back("a.sort_name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
query.bind("%" + utils::escapeLikeKeyword(keyword) + "%");
@@ -184,6 +185,31 @@ namespace lms::db
return session.getDboSession().query<int>("SELECT COUNT(*) FROM artist");
}
void Artist::find(Session& session, ArtistId& lastRetrievedArtist, std::size_t count, const std::function<void(const Artist::pointer&)>& func, MediaLibraryId library)
{
session.checkReadTransaction();
auto query{ session.getDboSession().query<Wt::Dbo::ptr<Artist>>("SELECT a FROM artist a")
.orderBy("a.id")
.where("a.id > ?").bind(lastRetrievedArtist)
.limit(static_cast<int>(count)) };
if (library.isValid())
{
query.join("track t ON t.id = t_a_l.track_id");
query.join("track_artist_link t_a_l ON t_a_l.artist_id = a.id");
query.where("t.media_library_id = ?").bind(library);
}
auto collection{ query.resultList() };
for (auto itResult{ collection.begin() }; itResult != collection.end(); ++itResult)
{
func(*itResult);
lastRetrievedArtist = (*itResult)->getId();
}
}
std::vector<Artist::pointer> Artist::find(Session& session, std::string_view name)
{
session.checkReadTransaction();
@@ -286,7 +312,7 @@ namespace lms::db
.groupBy("a.id")
.orderBy("COUNT(*) DESC, RANDOM()") };
for (TrackArtistLinkType type : artistLinkTypes)
for (const TrackArtistLinkType type : artistLinkTypes)
query.bind(type);
return utils::execQuery<ArtistId>(query, range);
@@ -304,7 +330,7 @@ namespace lms::db
where.And(WhereClause("a.id = ?")).bind(getId().toString());
{
WhereClause clusterClause;
for (ClusterTypeId clusterTypeId : clusterTypeIds)
for (const ClusterTypeId clusterTypeId : clusterTypeIds)
clusterClause.Or(WhereClause("c_type.id = ?")).bind(clusterTypeId.toString());
where.And(clusterClause);
@@ -320,7 +346,7 @@ namespace lms::db
Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> queryRes = query;
std::map<ClusterTypeId, std::vector<Cluster::pointer>> clustersByType;
for (Cluster::pointer cluster : queryRes)
for (const Cluster::pointer& cluster : queryRes)
{
if (clustersByType[cluster->getType()->getId()].size() < size)
clustersByType[cluster->getType()->getId()].push_back(cluster);
src/libs/database/impl/Release.cpp
+24
View File
@@ -293,6 +293,30 @@ namespace lms::db
return utils::execQuery<ReleaseId>(query, range);
}
void Release::find(Session& session, ReleaseId& lastRetrievedRelease, std::size_t count, const std::function<void(const Release::pointer&)>& func, MediaLibraryId library)
{
session.checkReadTransaction();
auto query{ session.getDboSession().query<Wt::Dbo::ptr<Release>>("SELECT r FROM release r")
.orderBy("r.id")
.where("r.id > ?").bind(lastRetrievedRelease)
.limit(static_cast<int>(count)) };
if (library.isValid())
{
query.join("track t ON t.release_id = r.id");
query.where("t.media_library_id = ?").bind(library);
}
auto collection{ query.resultList() };
for (auto itResult{ collection.begin() }; itResult != collection.end(); ++itResult)
{
func(*itResult);
lastRetrievedRelease = (*itResult)->getId();
}
}
RangeResults<Release::pointer> Release::find(Session& session, const FindParameters& params)
{
session.checkReadTransaction();
src/libs/database/include/database/Artist.hpp
+1
View File
@@ -86,6 +86,7 @@ namespace lms::db
static pointer find(Session& session, const core::UUID& MBID);
static pointer find(Session& session, ArtistId id);
static std::vector<pointer> find(Session& session, std::string_view name); // exact match on name field
static void find(Session& session, ArtistId& lastRetrievedArtist, std::size_t count, const std::function<void(const Artist::pointer&)>& func, MediaLibraryId library = {});
static RangeResults<pointer> find(Session& session, const FindParameters& parameters);
static void find(Session& session, const FindParameters& parameters, std::function<void(const pointer&)> func);
static RangeResults<ArtistId> findIds(Session& session, const FindParameters& parameters);
src/libs/database/include/database/IdType.hpp
+33 -33
View File
@@ -26,44 +26,44 @@
namespace lms::db
{
class IdType
{
public:
using ValueType = Wt::Dbo::dbo_default_traits::IdType;
class IdType
{
public:
using ValueType = Wt::Dbo::dbo_default_traits::IdType;
IdType() = default;
IdType(ValueType id) : _id {id} { assert(isValid()); }
IdType() = default;
IdType(ValueType id) : _id{ id } { assert(isValid()); }
bool isValid() const { return _id != Wt::Dbo::dbo_default_traits::invalidId(); }
std::string toString() const { assert(isValid()); return std::to_string(_id); }
bool isValid() const { return _id != Wt::Dbo::dbo_default_traits::invalidId(); }
std::string toString() const { assert(isValid()); return std::to_string(_id); }
ValueType getValue() const { return _id; }
ValueType getValue() const { return _id; }
auto operator<=>(const IdType& other) const = default; \
auto operator<=>(const IdType& other) const = default;
private:
Wt::Dbo::dbo_default_traits::IdType _id {Wt::Dbo::dbo_default_traits::invalidId()};
};
private:
Wt::Dbo::dbo_default_traits::IdType _id{ Wt::Dbo::dbo_default_traits::invalidId() };
};
#define LMS_DECLARE_IDTYPE(name) \
namespace lms::db { \
class name : public IdType \
{ \
public: \
using IdType::IdType; \
};\
} \
namespace std \
{ \
template<> \
class hash<lms::db::name> \
{ \
public: \
size_t operator()(lms::db::name id) const \
{ \
return std::hash<lms::db::name::ValueType>()(id.getValue()); \
} \
}; \
} // ns std
namespace lms::db { \
class name : public IdType \
{ \
public: \
using IdType::IdType; \
auto operator<=>(const name& other) const = default; \
};\
} \
namespace std \
{ \
template<> \
class hash<lms::db::name> \
{ \
public: \
size_t operator()(lms::db::name id) const \
{ \
return std::hash<lms::db::name::ValueType>()(id.getValue()); \
} \
}; \
} // ns std
} // namespace lms::db
src/libs/database/include/database/Release.hpp
+1
View File
@@ -122,6 +122,7 @@ namespace lms::db
static pointer find(Session& session, const core::UUID& MBID);
static std::vector<pointer> find(Session& session, const std::string& name, const std::filesystem::path& releaseDirectory);
static pointer find(Session& session, ReleaseId id);
static void find(Session& session, ReleaseId& lastRetrievedRelease, std::size_t count, const std::function<void(const Release::pointer&)>& func, MediaLibraryId library = {});
static RangeResults<pointer> find(Session& session, const FindParameters& parameters);
static void find(Session& session, const FindParameters& parameters, std::function<void(const pointer&)> func);
static RangeResults<ReleaseId> findIds(Session& session, const FindParameters& parameters);
src/libs/database/test/Artist.cpp
+116 -26
View File
@@ -77,6 +77,96 @@ namespace lms::db::tests
}
}
TEST_F(DatabaseFixture, Artist_findByRangedIdBased)
{
ScopedTrack track1{ session, "MyTrackFile1" };
ScopedTrack track2{ session, "MyTrackFile2" };
ScopedTrack track3{ session, "MyTrackFile3" };
ScopedArtist artist1{ session, "MyArtist1" };
ScopedArtist artist2{ session, "MyArtist2" };
ScopedArtist artist3{ session, "MyArtist3" };
ScopedMediaLibrary library{ session };
ScopedMediaLibrary otherLibrary{ session };
{
auto transaction{ session.createWriteTransaction() };
track2.get().modify()->setMediaLibrary(library.get());
TrackArtistLink::create(session, track1.get(), artist1.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track2.get(), artist2.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track3.get(), artist3.get(), TrackArtistLinkType::Artist);
}
{
auto transaction{ session.createReadTransaction() };
ArtistId lastRetrievedId;
std::vector<Artist::pointer> visitedArtists;
Artist::find(session, lastRetrievedId, 10, [&](const Artist::pointer& artist)
{
visitedArtists.push_back(artist);
});
ASSERT_EQ(visitedArtists.size(), 3);
EXPECT_EQ(visitedArtists[0]->getId(), artist1.getId());
EXPECT_EQ(visitedArtists[1]->getId(), artist2.getId());
EXPECT_EQ(visitedArtists[2]->getId(), artist3.getId());
EXPECT_EQ(lastRetrievedId, artist3.getId());
}
{
auto transaction{ session.createReadTransaction() };
ArtistId lastRetrievedId{ artist1.getId() };
std::vector<Artist::pointer> visitedArtists;
Artist::find(session, lastRetrievedId, 1, [&](const Artist::pointer& artist)
{
visitedArtists.push_back(artist);
});
ASSERT_EQ(visitedArtists.size(), 1);
EXPECT_EQ(visitedArtists[0]->getId(), artist2.getId());
EXPECT_EQ(lastRetrievedId, artist2.getId());
}
{
auto transaction{ session.createReadTransaction() };
ArtistId lastRetrievedId{ artist1.getId() };
std::vector<Artist::pointer> visitedArtists;
Artist::find(session, lastRetrievedId, 0, [&](const Artist::pointer& artist)
{
visitedArtists.push_back(artist);
});
ASSERT_EQ(visitedArtists.size(), 0);
EXPECT_EQ(lastRetrievedId, artist1.getId());
}
{
auto transaction{ session.createReadTransaction() };
ArtistId lastRetrievedId;
std::vector<Artist::pointer> visitedArtists;
Artist::find(session, lastRetrievedId, 10, [&](const Artist::pointer& artist)
{
visitedArtists.push_back(artist);
}, otherLibrary.getId());
ASSERT_EQ(visitedArtists.size(), 0);
EXPECT_EQ(lastRetrievedId, ArtistId{});
}
{
auto transaction{ session.createReadTransaction() };
ArtistId lastRetrievedId;
std::vector<Artist::pointer> visitedArtists;
Artist::find(session, lastRetrievedId, 10, [&](const Artist::pointer& artist)
{
visitedArtists.push_back(artist);
}, library.getId());
ASSERT_EQ(visitedArtists.size(), 1);
EXPECT_EQ(visitedArtists[0]->getId(), artist2.getId());
EXPECT_EQ(lastRetrievedId, artist2.getId());
}
}
TEST_F(DatabaseFixture, MultipleArtists)
{
{
@@ -409,46 +499,46 @@ namespace lms::db::tests
EXPECT_EQ(artists.front()->getId(), artist1.getId());
EXPECT_EQ(Artist::find(session, R"(MyArtistFoo)").size(), 0);
}
{
const auto artists{ Artist::find(session, R"(%MyArtist)") };
ASSERT_TRUE(artists.size() == 1);
EXPECT_EQ(artists.front()->getId(), artist2.getId());
{
const auto artists{ Artist::find(session, R"(%MyArtist)") };
ASSERT_TRUE(artists.size() == 1);
EXPECT_EQ(artists.front()->getId(), artist2.getId());
EXPECT_EQ(Artist::find(session, R"(FooMyArtist)").size(), 0);
}
{
const auto artists{ Artist::find(session, R"(%_MyArtist)") };
ASSERT_TRUE(artists.size() == 1);
ASSERT_EQ(artists.front()->getId(), artist3.getId());
EXPECT_EQ(Artist::find(session, R"(%CMyArtist)").size(), 0);
}
}
{
const auto artists{ Artist::find(session, R"(%_MyArtist)") };
ASSERT_TRUE(artists.size() == 1);
ASSERT_EQ(artists.front()->getId(), artist3.getId());
EXPECT_EQ(Artist::find(session, R"(%CMyArtist)").size(), 0);
}
auto transaction{ session.createReadTransaction() };
{
const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"MyArtist"})) };
EXPECT_EQ(artists.results.size(), 6);
}
{
auto transaction{ session.createReadTransaction() };
{
const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"MyArtist"})) };
EXPECT_EQ(artists.results.size(), 6);
}
{
const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"MyArtist%"}).setSortMethod(ArtistSortMethod::ByName)) };
ASSERT_EQ(artists.results.size(), 2);
const auto artists{ Artist::findIds(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());
}
EXPECT_EQ(artists.results[1], artist4.getId());
}
{
const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"%MyArtist"}).setSortMethod(ArtistSortMethod::ByName)) };
{
const auto artists{ Artist::findIds(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());
EXPECT_EQ(artists.results[1], artist5.getId());
}
{
const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"_MyArtist"}).setSortMethod(ArtistSortMethod::ByName)) };
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results[0], artist3.getId());
}
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results[0], artist3.getId());
}
}
}
src/libs/database/test/Release.cpp
+90
View File
@@ -74,6 +74,96 @@ namespace lms::db::tests
}
}
TEST_F(DatabaseFixture, Release_findByRangedIdBased)
{
ScopedTrack track1{ session, "MyTrackFile1" };
ScopedTrack track2{ session, "MyTrackFile2" };
ScopedTrack track3{ session, "MyTrackFile3" };
ScopedRelease release1{ session, "MyRelease1" };
ScopedRelease release2{ session, "MyRelease2" };
ScopedRelease release3{ session, "MyRelease3" };
ScopedMediaLibrary library{ session };
ScopedMediaLibrary otherLibrary{ session };
{
auto transaction{ session.createWriteTransaction() };
track2.get().modify()->setMediaLibrary(library.get());
track1.get().modify()->setRelease(release1.get());
track2.get().modify()->setRelease(release2.get());
track3.get().modify()->setRelease(release3.get());
}
{
auto transaction{ session.createReadTransaction() };
ReleaseId lastRetrievedId;
std::vector<Release::pointer> visitedReleases;
Release::find(session, lastRetrievedId, 10, [&](const Release::pointer& release)
{
visitedReleases.push_back(release);
});
ASSERT_EQ(visitedReleases.size(), 3);
EXPECT_EQ(visitedReleases[0]->getId(), release1.getId());
EXPECT_EQ(visitedReleases[1]->getId(), release2.getId());
EXPECT_EQ(visitedReleases[2]->getId(), release3.getId());
EXPECT_EQ(lastRetrievedId, release3.getId());
}
{
auto transaction{ session.createReadTransaction() };
ReleaseId lastRetrievedId{ release1.getId() };
std::vector<Release::pointer> visitedReleases;
Release::find(session, lastRetrievedId, 1, [&](const Release::pointer& release)
{
visitedReleases.push_back(release);
});
ASSERT_EQ(visitedReleases.size(), 1);
EXPECT_EQ(visitedReleases[0]->getId(), release2.getId());
EXPECT_EQ(lastRetrievedId, release2.getId());
}
{
auto transaction{ session.createReadTransaction() };
ReleaseId lastRetrievedId{ release1.getId() };
std::vector<Release::pointer> visitedReleases;
Release::find(session, lastRetrievedId, 0, [&](const Release::pointer& release)
{
visitedReleases.push_back(release);
});
ASSERT_EQ(visitedReleases.size(), 0);
EXPECT_EQ(lastRetrievedId, release1.getId());
}
{
auto transaction{ session.createReadTransaction() };
ReleaseId lastRetrievedId;
std::vector<Release::pointer> visitedReleases;
Release::find(session, lastRetrievedId, 10, [&](const Release::pointer& release)
{
visitedReleases.push_back(release);
}, otherLibrary.getId());
ASSERT_EQ(visitedReleases.size(), 0);
EXPECT_EQ(lastRetrievedId, ReleaseId{});
}
{
auto transaction{ session.createReadTransaction() };
ReleaseId lastRetrievedId;
std::vector<Release::pointer> visitedReleases;
Release::find(session, lastRetrievedId, 10, [&](const Release::pointer& release)
{
visitedReleases.push_back(release);
}, library.getId());
ASSERT_EQ(visitedReleases.size(), 1);
EXPECT_EQ(visitedReleases[0]->getId(), release2.getId());
EXPECT_EQ(lastRetrievedId, release2.getId());
}
}
TEST_F(DatabaseFixture, Release_singleTrack)
{
ScopedRelease release{ session, "MyRelease" };
src/libs/subsonic/impl/entrypoints/Searching.cpp
+215 -109
View File
@@ -23,6 +23,7 @@
#include <mutex>
#include <map>
#include "core/Random.hpp"
#include "database/Artist.hpp"
#include "database/Release.hpp"
#include "database/Session.hpp"
@@ -59,7 +60,6 @@ namespace lms::api::subsonic
ObjectId extractLastRetrievedObjectId(const ScanInfo& info);
void setObjectId(const ScanInfo& info, ObjectId lastRetrievedId);
void cleanOutdatedScanEntries();
private:
using ClockType = std::chrono::steady_clock;
@@ -70,6 +70,7 @@ namespace lms::api::subsonic
ObjectId objectId;
};
static constexpr std::size_t maxScanCount{ 50 };
static constexpr ClockType::duration maxEntryDuration{ std::chrono::seconds{30} };
std::mutex _mutex;
@@ -81,12 +82,15 @@ namespace lms::api::subsonic
{
ObjectId res;
const std::scoped_lock lock{ _mutex };
auto it{ _ongoingScans.find(scanInfo) };
if (it != _ongoingScans.end())
{
res = it->second.objectId;
_ongoingScans.erase(it);
const std::scoped_lock lock{ _mutex };
auto it{ _ongoingScans.find(scanInfo) };
if (it != _ongoingScans.end())
{
res = it->second.objectId;
_ongoingScans.erase(it);
}
}
return res;
@@ -94,18 +98,212 @@ namespace lms::api::subsonic
template<typename ObjectId>
void ScanTracker<ObjectId>::setObjectId(const ScanInfo& scanInfo, ObjectId lastRetrievedId)
{
const std::scoped_lock lock{ _mutex };
_ongoingScans[scanInfo] = { ClockType::now(), lastRetrievedId };
}
template<typename ObjectId>
void ScanTracker<ObjectId>::cleanOutdatedScanEntries()
{
const ClockType::time_point now{ ClockType::now() };
const std::scoped_lock lock{ _mutex };
// clean outdated scan entries; we do this to not have to flush everything each time we add/remove entries in the database
std::erase_if(_ongoingScans, [&](const auto& entry) { return now > entry.second.timePoint + maxEntryDuration; });
// prevent the cache size from going out of control
if (_ongoingScans.size() == maxScanCount)
_ongoingScans.erase(core::random::pickRandom(_ongoingScans));
_ongoingScans[scanInfo] = { now, lastRetrievedId };
}
void findRequestedArtists(RequestContext& context, bool id3, const std::vector<std::string_view>& keywords, MediaLibraryId mediaLibrary, const User::pointer& user, Response::Node& searchResultNode)
{
static ScanTracker<ArtistId> currentScansInProgress;
const std::size_t artistCount{ getParameterAs<std::size_t>(context.parameters, "artistCount").value_or(20) };
if (artistCount == 0)
return;
if (artistCount > defaultMaxCountSize)
throw ParameterValueTooHighGenericError{ "artistCount", defaultMaxCountSize };
const std::size_t artistOffset{ getParameterAs<std::size_t>(context.parameters, "artistOffset").value_or(0) };
ArtistId lastRetrievedId;
auto findArtists{ [&]
{
Artist::FindParameters params;
params.setKeywords(keywords);
params.setRange(Range{ artistOffset, artistCount });
params.setMediaLibrary(mediaLibrary);
Artist::find(context.dbSession, params, [&](const Artist::pointer& artist)
{
searchResultNode.addArrayChild("artist", createArtistNode(context, artist, user, id3));
lastRetrievedId = artist->getId();
});
} };
if (!keywords.empty())
{
findArtists();
}
else
{
ScanTracker<ArtistId>::ScanInfo scanInfo
{
.clientAddress = context.clientInfo.ipAddress,
.clientName = context.clientInfo.name,
.userName = context.clientInfo.user,
.library = mediaLibrary,
.offset = artistOffset
};
if (ArtistId cachedLastRetrievedId{ currentScansInProgress.extractLastRetrievedObjectId(scanInfo) }; cachedLastRetrievedId.isValid())
{
Artist::find(context.dbSession, cachedLastRetrievedId, artistCount, [&](const Artist::pointer& artist)
{
searchResultNode.addArrayChild("artist", createArtistNode(context, artist, user, id3));
}, mediaLibrary);
lastRetrievedId = cachedLastRetrievedId;
}
else
{
findArtists();
}
if (lastRetrievedId.isValid())
{
scanInfo.offset = artistOffset + artistCount;
currentScansInProgress.setObjectId(scanInfo, lastRetrievedId);
}
}
}
void findRequestedAlbums(RequestContext& context, bool id3, const std::vector<std::string_view>& keywords, MediaLibraryId mediaLibrary, const User::pointer& user, Response::Node& searchResultNode)
{
static ScanTracker<ReleaseId> currentScansInProgress;
const std::size_t albumCount{ getParameterAs<std::size_t>(context.parameters, "albumCount").value_or(20) };
if (albumCount == 0)
return;
if (albumCount > defaultMaxCountSize)
throw ParameterValueTooHighGenericError{ "albumCount", defaultMaxCountSize };
const std::size_t albumOffset{ getParameterAs<std::size_t>(context.parameters, "albumOffset").value_or(0) };
ReleaseId lastRetrievedId;
auto findReleases{ [&]
{
Release::FindParameters params;
params.setKeywords(keywords);
params.setRange(Range{ albumOffset, albumCount });
params.setMediaLibrary(mediaLibrary);
Release::find(context.dbSession, params, [&](const Release::pointer& release)
{
searchResultNode.addArrayChild("album", createAlbumNode(context, release, user, id3));
lastRetrievedId = release->getId();
});
} };
if (!keywords.empty())
{
findReleases();
}
else
{
ScanTracker<ReleaseId>::ScanInfo scanInfo
{
.clientAddress = context.clientInfo.ipAddress,
.clientName = context.clientInfo.name,
.userName = context.clientInfo.user,
.library = mediaLibrary,
.offset = albumOffset
};
if (ReleaseId cachedLastRetrievedId{ currentScansInProgress.extractLastRetrievedObjectId(scanInfo) }; cachedLastRetrievedId.isValid())
{
Release::find(context.dbSession, cachedLastRetrievedId, albumCount, [&](const Release::pointer& release)
{
searchResultNode.addArrayChild("album", createAlbumNode(context, release, user, id3));
}, mediaLibrary);
lastRetrievedId = cachedLastRetrievedId;
}
else
{
findReleases();
}
if (lastRetrievedId.isValid())
{
scanInfo.offset = albumOffset + albumCount;
currentScansInProgress.setObjectId(scanInfo, lastRetrievedId);
}
}
}
void findRequestedTracks(RequestContext& context, const std::vector<std::string_view>& keywords, MediaLibraryId mediaLibrary, const User::pointer& user, Response::Node& searchResultNode)
{
static ScanTracker<TrackId> currentScansInProgress;
const std::size_t songCount{ getParameterAs<std::size_t>(context.parameters, "songCount").value_or(20) };
if (songCount == 0)
return;
if (songCount > defaultMaxCountSize)
throw ParameterValueTooHighGenericError{ "songCount", defaultMaxCountSize };
const std::size_t songOffset{ getParameterAs<std::size_t>(context.parameters, "songOffset").value_or(0) };
TrackId lastRetrievedId;
auto findTracks{ [&]
{
Track::FindParameters params;
params.setKeywords(keywords);
params.setRange(Range{ songOffset, songCount });
params.setMediaLibrary(mediaLibrary);
Track::find(context.dbSession, params, [&](const Track::pointer& track)
{
searchResultNode.addArrayChild("song", createSongNode(context, track, user));
lastRetrievedId = track->getId();
});
} };
if (!keywords.empty())
{
findTracks();
}
else
{
ScanTracker<TrackId>::ScanInfo scanInfo
{
.clientAddress = context.clientInfo.ipAddress,
.clientName = context.clientInfo.name,
.userName = context.clientInfo.user,
.library = mediaLibrary,
.offset = songOffset
};
if (TrackId cachedLastRetrievedId{ currentScansInProgress.extractLastRetrievedObjectId(scanInfo) }; cachedLastRetrievedId.isValid())
{
Track::find(context.dbSession, cachedLastRetrievedId, songCount, [&](const Track::pointer& track)
{
searchResultNode.addArrayChild("song", createSongNode(context, track, user));
}, mediaLibrary);
lastRetrievedId = cachedLastRetrievedId;
}
else
{
findTracks();
}
if (lastRetrievedId.isValid())
{
scanInfo.offset = songOffset + songCount;
currentScansInProgress.setObjectId(scanInfo, lastRetrievedId);
}
}
}
}
@@ -118,21 +316,8 @@ namespace lms::api::subsonic
std::string_view query{ queryString };
// Optional params
const std::size_t artistCount{ getParameterAs<std::size_t>(context.parameters, "artistCount").value_or(20) };
const std::size_t artistOffset{ getParameterAs<std::size_t>(context.parameters, "artistOffset").value_or(0) };
const std::size_t albumCount{ getParameterAs<std::size_t>(context.parameters, "albumCount").value_or(20) };
const std::size_t albumOffset{ getParameterAs<std::size_t>(context.parameters, "albumOffset").value_or(0) };
const std::size_t songCount{ getParameterAs<std::size_t>(context.parameters, "songCount").value_or(20) };
const std::size_t songOffset{ getParameterAs<std::size_t>(context.parameters, "songOffset").value_or(0) };
const MediaLibraryId mediaLibrary{ getParameterAs<MediaLibraryId>(context.parameters, "musicFolderId").value_or(MediaLibraryId{}) };
if (artistCount > defaultMaxCountSize)
throw ParameterValueTooHighGenericError{ "artistCount", defaultMaxCountSize };
if (albumCount > defaultMaxCountSize)
throw ParameterValueTooHighGenericError{ "albumCount", defaultMaxCountSize };
if (songCount > defaultMaxCountSize)
throw ParameterValueTooHighGenericError{ "songCount", defaultMaxCountSize };
// Symfonium adds extra ""
if (context.clientInfo.name == "Symfonium")
query = core::stringUtils::stringTrim(query, "\"");
@@ -142,7 +327,7 @@ namespace lms::api::subsonic
keywords = core::stringUtils::splitString(query, ' ');
Response response{ Response::createOkResponse(context.serverProtocolVersion) };
Response::Node& searchResult2Node{ response.createNode(id3 ? "searchResult3" : "searchResult2") };
Response::Node& searchResultNode{ response.createNode(id3 ? "searchResult3" : "searchResult2") };
auto transaction{ context.dbSession.createReadTransaction() };
@@ -150,88 +335,9 @@ namespace lms::api::subsonic
if (!user)
throw UserNotAuthorizedError{};
if (artistCount > 0)
{
Artist::FindParameters params;
params.setKeywords(keywords);
params.setRange(Range{ artistOffset, artistCount });
params.setMediaLibrary(mediaLibrary);
Artist::find(context.dbSession, params, [&](const Artist::pointer& artist)
{
searchResult2Node.addArrayChild("artist", createArtistNode(context, artist, user, id3));
});
}
if (albumCount > 0)
{
Release::FindParameters params;
params.setKeywords(keywords);
params.setRange(Range{ albumOffset, albumCount });
params.setMediaLibrary(mediaLibrary);
Release::find(context.dbSession, params, [&](const Release::pointer& release)
{
searchResult2Node.addArrayChild("album", createAlbumNode(context, release, user, id3));
});
}
if (songCount > 0)
{
static ScanTracker<TrackId> currentScansInProgress;
currentScansInProgress.cleanOutdatedScanEntries();
TrackId lastRetrievedId;
auto findTracks{ [&]
{
Track::FindParameters params;
params.setKeywords(keywords);
params.setRange(Range{ songOffset, songCount });
params.setMediaLibrary(mediaLibrary);
Track::find(context.dbSession, params, [&](const Track::pointer& track)
{
searchResult2Node.addArrayChild("song", createSongNode(context, track, user));
lastRetrievedId = track->getId();
});
} };
if (!keywords.empty())
{
findTracks();
}
else
{
ScanTracker<TrackId>::ScanInfo scanInfo
{
.clientAddress = context.clientInfo.ipAddress,
.clientName = context.clientInfo.name,
.userName = context.clientInfo.user,
.library = mediaLibrary,
.offset = songOffset
};
if (TrackId cachedLastRetrievedId{ currentScansInProgress.extractLastRetrievedObjectId(scanInfo) }; cachedLastRetrievedId.isValid())
{
Track::find(context.dbSession, cachedLastRetrievedId, songCount, [&](const Track::pointer& track)
{
searchResult2Node.addArrayChild("song", createSongNode(context, track, user));
}, mediaLibrary);
lastRetrievedId = cachedLastRetrievedId;
}
else
{
findTracks();
}
if (lastRetrievedId.isValid())
{
scanInfo.offset = songOffset + songCount;
currentScansInProgress.setObjectId(scanInfo, lastRetrievedId);
}
}
}
findRequestedArtists(context, id3, keywords, mediaLibrary, user, searchResultNode);
findRequestedAlbums(context, id3, keywords, mediaLibrary, user, searchResultNode);
findRequestedTracks(context, keywords, mediaLibrary, user, searchResultNode);
return response;
}