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

Databsae service refactoring. Warning, loses stars and listens stats

Browse Source
This commit is contained in:
emeric
2021-12-04 15:25:09 +01:00
parent 97aba4ae82
commit 0cf6b2159e
160 changed files with 6047 additions and 3477 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/services/database/CMakeLists.txt
+6
View File
@@ -1,16 +1,22 @@
add_library(lmsdatabase SHARED
impl/Artist.cpp
impl/AuthToken.cpp
impl/Cluster.cpp
impl/Db.cpp
impl/Listen.cpp
impl/TrackArtistLink.cpp
impl/TrackFeatures.cpp
impl/TrackList.cpp
impl/Release.cpp
impl/ScanSettings.cpp
impl/Session.cpp
impl/StarredArtist.cpp
impl/StarredRelease.cpp
impl/StarredTrack.cpp
impl/SqlQuery.cpp
impl/Track.cpp
impl/TrackBookmark.cpp
impl/Types.cpp
impl/User.cpp
impl/Utils.cpp
)
src/libs/services/database/impl/Artist.cpp
+79 -288
View File
@@ -28,7 +28,7 @@
#include "utils/Logger.hpp"
#include "SqlQuery.hpp"
#include "Utils.hpp"
#include "Traits.hpp"
#include "IdTypeTraits.hpp"
namespace Database
{
@@ -40,8 +40,16 @@ _MBID {MBID ? MBID->getAsString() : ""}
{
}
std::size_t
Artist::getCount(Session& session)
{
session.checkSharedLocked();
return session.getDboSession().query<int>("SELECT COUNT(*) FROM artist");
}
std::vector<Artist::pointer>
Artist::getByName(Session& session, const std::string& name)
Artist::find(Session& session, const std::string& name)
{
session.checkSharedLocked();
@@ -53,14 +61,14 @@ Artist::getByName(Session& session, const std::string& name)
}
Artist::pointer
Artist::getByMBID(Session& session, const UUID& mbid)
Artist::find(Session& session, const UUID& mbid)
{
session.checkSharedLocked();
return session.getDboSession().find<Artist>().where("mbid = ?").bind(std::string {mbid.getAsString()}).resultValue();
}
Artist::pointer
Artist::getById(Session& session, ArtistId id)
Artist::find(Session& session, ArtistId id)
{
session.checkSharedLocked();
return session.getDboSession().find<Artist>().where("id = ?").bind(id).resultValue();
@@ -84,36 +92,37 @@ Artist::create(Session& session, const std::string& name, const std::optional<UU
return res;
}
template <typename T>
static
Wt::Dbo::Query<T>
createQuery(Session& session,
const std::string& queryStr,
const std::vector<ClusterId>& clusterIds,
const std::vector<std::string_view>& keywords,
std::optional<TrackArtistLinkType> linkType)
Wt::Dbo::Query<ArtistId>
createQuery(Session& session, const Artist::FindParameters& params)
{
session.checkSharedLocked();
auto query {session.getDboSession().query<T>(queryStr)};
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");
auto query {session.getDboSession().query<ArtistId>("SELECT DISTINCT a.id FROM artist a")};
if (params.sortMethod == ArtistSortMethod::LastWritten || params.writtenAfter.isValid() || params.linkType)
{
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");
}
if (linkType)
query.where("t_a_l.type = ?").bind(*linkType);
if (params.linkType)
query.where("t_a_l.type = ?").bind(*params.linkType);
if (!keywords.empty())
if (params.writtenAfter.isValid())
query.where("t.file_last_write > ?").bind(params.writtenAfter);
if (!params.keywords.empty())
{
std::vector<std::string> clauses;
std::vector<std::string> sortClauses;
for (std::string_view keyword : keywords)
for (std::string_view keyword : params.keywords)
{
clauses.push_back("a.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
query.bind("%" + escapeLikeKeyword(keyword) + "%");
}
for (std::string_view keyword : keywords)
for (std::string_view keyword : params.keywords)
{
sortClauses.push_back("a.sort_name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
query.bind("%" + escapeLikeKeyword(keyword) + "%");
@@ -122,7 +131,15 @@ createQuery(Session& session,
query.where("(" + StringUtils::joinStrings(clauses, " AND ") + ") OR (" + StringUtils::joinStrings(sortClauses, " AND ") + ")");
}
if (!clusterIds.empty())
if (params.starringUser.isValid())
{
assert(params.scrobbler);
query.join("starred_artist s_a ON s_a.artist_id = a.id")
.where("s_a.user_id = ?").bind(params.starringUser)
.where("s_a.scrobbler = ?").bind(*params.scrobbler);
}
if (!params.clusters.empty())
{
std::ostringstream oss;
oss << "a.id IN (SELECT DISTINCT a.id FROM artist a"
@@ -132,268 +149,59 @@ createQuery(Session& session,
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
WhereClause clusterClause;
for (const ClusterId clusterId : clusterIds)
for (const ClusterId clusterId : params.clusters)
{
clusterClause.Or(WhereClause("c.id = ?"));
query.bind(clusterId);
}
oss << " " << clusterClause.get();
oss << " GROUP BY t.id,a.id HAVING COUNT(DISTINCT c.id) = " << clusterIds.size() << ")";
oss << " GROUP BY t.id,a.id HAVING COUNT(DISTINCT c.id) = " << params.clusters.size() << ")";
query.where(oss.str());
}
switch (params.sortMethod)
{
case ArtistSortMethod::None:
break;
case ArtistSortMethod::ByName:
query.orderBy("a.name COLLATE NOCASE");
break;
case ArtistSortMethod::BySortName:
query.orderBy("a.sort_name COLLATE NOCASE");
break;
case ArtistSortMethod::Random:
query.orderBy("RANDOM()");
break;
case ArtistSortMethod::LastWritten:
query.orderBy("t.file_last_write DESC");
break;
case ArtistSortMethod::StarredDateDesc:
assert(params.starringUser.isValid());
query.orderBy("s_a.date_time DESC");
break;
}
return query;
}
std::vector<Artist::pointer>
Artist::getAll(Session& session)
RangeResults<ArtistId>
Artist::findAllOrphans(Session& session, Range range)
{
session.checkSharedLocked();
auto query {session.getDboSession().query<ArtistId>("SELECT DISTINCT a.id FROM artist a WHERE NOT EXISTS(SELECT 1 FROM track t INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id WHERE t.id = t_a_l.track_id)")};
Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res = session.getDboSession().find<Artist>();
return std::vector<pointer>(res.begin(), res.end());
return execQuery(query, range);
}
std::vector<Artist::pointer>
Artist::getAll(Session& session, SortMethod sortMethod)
RangeResults<ArtistId>
Artist::find(Session& session, const FindParameters& params)
{
session.checkSharedLocked();
auto query {session.getDboSession().find<Artist>()};
switch (sortMethod)
{
case Artist::SortMethod::None:
break;
case Artist::SortMethod::ByName:
query.orderBy("name COLLATE NOCASE");
break;
case Artist::SortMethod::BySortName:
query.orderBy("sort_name COLLATE NOCASE");
break;
}
Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res = query;
return std::vector<pointer>(res.begin(), res.end());
}
std::vector<Artist::pointer>
Artist::getAll(Session& session, SortMethod sortMethod, std::optional<Range> range, bool& moreResults)
{
session.checkSharedLocked();
auto query {createQuery<Wt::Dbo::ptr<Artist>>(session, "SELECT a FROM Artist a", {}, {}, std::nullopt)};
switch (sortMethod)
{
case Artist::SortMethod::None:
break;
case Artist::SortMethod::ByName:
query.orderBy("a.name COLLATE NOCASE");
break;
case Artist::SortMethod::BySortName:
query.orderBy("a.sort_name COLLATE NOCASE");
break;
}
Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection = query
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1);
std::vector<Artist::pointer> res (collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return res;
}
std::vector<ArtistId>
Artist::getAllIds(Session& session)
{
session.checkSharedLocked();
Wt::Dbo::collection<ArtistId> res = session.getDboSession().query<ArtistId>("SELECT id FROM artist");
return std::vector<ArtistId>(res.begin(), res.end());
}
std::vector<ArtistId>
Artist::getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<TrackArtistLinkType> linkType, std::optional<std::size_t> size)
{
session.checkSharedLocked();
auto query {createQuery<ArtistId>(session, "SELECT DISTINCT a.id from artist a", clusters, {}, linkType)};
Wt::Dbo::collection<ArtistId> res = query
.orderBy("RANDOM()")
.limit(size ? static_cast<int>(*size) : -1);
return std::vector<ArtistId>(res.begin(), res.end());
}
std::vector<Artist::pointer>
Artist::getAllOrphans(Session& session)
{
session.checkSharedLocked();
Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res {session.getDboSession().query<Wt::Dbo::ptr<Artist>>("SELECT DISTINCT a FROM artist a WHERE NOT EXISTS(SELECT 1 FROM track t INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id WHERE t.id = t_a_l.track_id)")};
return std::vector<pointer>(res.begin(), res.end());
}
std::vector<ArtistId>
Artist::getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit)
{
session.checkSharedLocked();
Wt::Dbo::collection<ArtistId> res = session.getDboSession().query<ArtistId>
("SELECT DISTINCT a.id FROM artist a"
" INNER JOIN track t ON t.id = t_a_l.track_id INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
.limit(limit ? static_cast<int>(*limit) : -1);
return std::vector<ArtistId>(res.begin(), res.end());
}
std::vector<Artist::pointer>
Artist::getByClusters(Session& session, const std::vector<ClusterId>& clusters, SortMethod sortMethod)
{
assert(!clusters.empty());
session.checkSharedLocked();
bool more{};
return getByFilter(session, clusters, {}, std::nullopt, sortMethod, std::nullopt, more);
}
std::vector<Artist::pointer>
Artist::getByFilter(Session& session,
const std::vector<ClusterId>& clusters,
const std::vector<std::string_view>& keywords,
std::optional<TrackArtistLinkType> linkType,
SortMethod sortMethod,
std::optional<Range> range,
bool& moreResults)
{
session.checkSharedLocked();
auto query {createQuery<Wt::Dbo::ptr<Artist>>(session, "SELECT DISTINCT a from artist a", clusters, keywords, linkType)};
switch (sortMethod)
{
case Artist::SortMethod::None:
break;
case Artist::SortMethod::ByName:
query.orderBy("a.name COLLATE NOCASE");
break;
case Artist::SortMethod::BySortName:
query.orderBy("a.sort_name COLLATE NOCASE");
break;
}
Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection = query
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1);
std::vector<pointer> res (collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return res;
}
std::vector<Artist::pointer>
Artist::getLastWritten(Session& session,
std::optional<Wt::WDateTime> after,
const std::vector<ClusterId>& clusters,
std::optional<TrackArtistLinkType> linkType,
std::optional<Range> range, bool& moreResults)
{
session.checkSharedLocked();
auto query {createQuery<Wt::Dbo::ptr<Artist>>(session, "SELECT DISTINCT a from artist a", clusters, {}, linkType)};
if (after)
query.where("t.file_last_write > ?").bind(*after);
Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection = query
.orderBy("t.file_last_write DESC")
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1);
std::vector<pointer> res (collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return std::vector<pointer>(res.begin(), res.end());
}
std::vector<Artist::pointer>
Artist::getStarred(Session& session,
User::pointer user,
const std::vector<ClusterId>& clusters,
std::optional<TrackArtistLinkType> linkType,
SortMethod sortMethod,
std::optional<Range> range, bool& moreResults)
{
session.checkSharedLocked();
auto query {createQuery<Wt::Dbo::ptr<Artist>>(session, "SELECT DISTINCT a from artist a", clusters, {}, linkType)};
{
std::ostringstream oss;
oss << "a.id IN (SELECT DISTINCT a.id FROM artist a"
" INNER JOIN user_artist_starred uas ON uas.artist_id = a.id"
" INNER JOIN user u ON u.id = uas.user_id WHERE u.id = ?)";
query.bind(user->getId());
query.where(oss.str());
}
switch (sortMethod)
{
case Artist::SortMethod::None:
break;
case Artist::SortMethod::ByName:
query.orderBy("name COLLATE NOCASE");
break;
case Artist::SortMethod::BySortName:
query.orderBy("sort_name COLLATE NOCASE");
break;
}
Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection = query
.groupBy("a.id")
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1);
std::vector<pointer> res (collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return std::vector<pointer>(res.begin(), res.end());
auto query {createQuery(session, params)};
return execQuery(query, params.range);
}
std::vector<Release::pointer>
@@ -463,32 +271,19 @@ Artist::getTracks(std::optional<TrackArtistLinkType> linkType) const
return std::vector<Track::pointer>(tracks.begin(), tracks.end());
}
std::vector<Track::pointer>
Artist::getNonReleaseTracks(std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const
RangeResults<Track::pointer>
Artist::getNonReleaseTracks(std::optional<TrackArtistLinkType> linkType, Range range) const
{
assert(session());
auto query {session()->query<Wt::Dbo::ptr<Track>>("SELECT t FROM track t INNER JOIN artist a ON a.id = t_a_l.artist_id INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id")
.where("a.id = ?").bind(getId())
.where("t.release_id is NULL")
.orderBy("t.name")
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1)};
.orderBy("t.name")};
if (linkType)
query.where("t_a_l.type = ?").bind(*linkType);
Wt::Dbo::collection<Wt::Dbo::ptr<Track>> tracks {query.resultList()};
std::vector<Track::pointer> res(tracks.begin(), tracks.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return res;
return execQuery(query, range);
}
bool
@@ -518,14 +313,14 @@ Artist::getRandomTracks(std::optional<std::size_t> count) const
return std::vector<Track::pointer>(tracks.begin(), tracks.end());
}
std::vector<Artist::pointer>
Artist::getSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes, std::optional<Range> range) const
RangeResults<ArtistId>
Artist::findSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes, Range range) const
{
assert(session());
std::ostringstream oss;
oss <<
"SELECT a FROM artist a"
"SELECT a.id FROM artist a"
" INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
" INNER JOIN track t ON t.id = t_a_l.track_id"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
@@ -554,19 +349,15 @@ Artist::getSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes, std::opt
oss << ")";
}
Wt::Dbo::Query<Wt::Dbo::ptr<Artist>> query {session()->query<Wt::Dbo::ptr<Artist>>(oss.str())
auto query {session()->query<ArtistId>(oss.str())
.bind(getId())
.bind(getId())
.groupBy("a.id")
.orderBy("COUNT(*) DESC, RANDOM()")
.limit(range ? static_cast<int>(range->limit) : -1)
.offset(range ? static_cast<int>(range->offset) : -1)};
.orderBy("COUNT(*) DESC, RANDOM()")};
for (TrackArtistLinkType type : artistLinkTypes)
query.bind(type);
Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res {query.resultList()};
return std::vector<pointer>(res.begin(), res.end());
return execQuery(query, range);
}
std::vector<std::vector<Cluster::pointer>>
src/libs/services/database/impl/AuthToken.cpp
+67
View File
@@ -0,0 +1,67 @@
/*
* Copyright (C) 2013 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "services/database/AuthToken.hpp"
#include <Wt/Dbo/WtSqlTraits.h>
#include "services/database/Session.hpp"
#include "services/database/User.hpp"
#include "StringViewTraits.hpp"
#include "IdTypeTraits.hpp"
namespace Database
{
AuthToken::AuthToken(std::string_view value, const Wt::WDateTime& expiry, ObjectPtr<User> user)
: _value {value}
, _expiry {expiry}
, _user {getDboPtr(user)}
{
}
AuthToken::pointer
AuthToken::create(Session& session, std::string_view value, const Wt::WDateTime& expiry, ObjectPtr<User> user)
{
session.checkUniqueLocked();
AuthToken::pointer res {session.getDboSession().add(std::make_unique<AuthToken>(value, expiry, user))};
session.getDboSession().flush();
return res;
}
void
AuthToken::removeExpiredTokens(Session& session, const Wt::WDateTime& now)
{
session.checkUniqueLocked();
session.getDboSession().execute("DELETE FROM auth_token WHERE expiry < ?").bind(now);
}
AuthToken::pointer
AuthToken::find(Session& session, std::string_view value)
{
session.checkSharedLocked();
return session.getDboSession().find<AuthToken>()
.where("value = ?").bind(value)
.resultValue();
}
}
src/libs/services/database/impl/Cluster.cpp
+55 -49
View File
@@ -24,8 +24,9 @@
#include "services/database/ScanSettings.hpp"
#include "services/database/Session.hpp"
#include "services/database/Track.hpp"
#include "IdTypeTraits.hpp"
#include "SqlQuery.hpp"
#include "Traits.hpp"
#include "Utils.hpp"
namespace Database {
@@ -35,6 +36,14 @@ Cluster::Cluster(ObjectPtr<ClusterType> type, std::string_view name)
{
}
std::size_t
Cluster::getCount(Session& session)
{
session.checkSharedLocked();
return session.getDboSession().query<int>("SELECT COUNT(*) FROM cluster");
}
Cluster::pointer
Cluster::create(Session& session, ObjectPtr<ClusterType> type, std::string_view name)
{
@@ -46,25 +55,26 @@ Cluster::create(Session& session, ObjectPtr<ClusterType> type, std::string_view
return res;
}
std::vector<Cluster::pointer>
Cluster::getAll(Session& session)
RangeResults<ClusterId>
Cluster::find(Session& session, Range range)
{
session.checkSharedLocked();
auto query {session.getDboSession().query<ClusterId>("SELECT id FROM cluster")};
Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> res {session.getDboSession().find<Cluster>()};
return std::vector<Cluster::pointer>(res.begin(), res.end());
return execQuery(query, range);
}
std::vector<Cluster::pointer>
Cluster::getAllOrphans(Session& session)
RangeResults<ClusterId>
Cluster::findOrphans(Session& session, Range range)
{
session.checkSharedLocked();
auto res {session.getDboSession().query<Wt::Dbo::ptr<Cluster>>("SELECT DISTINCT c FROM cluster c WHERE NOT EXISTS(SELECT 1 FROM track_cluster t_c WHERE t_c.cluster_id = c.id)").resultList()};
return std::vector<Cluster::pointer>(res.begin(), res.end());
auto query {session.getDboSession().query<ClusterId>("SELECT DISTINCT c.id FROM cluster c WHERE NOT EXISTS(SELECT 1 FROM track_cluster t_c WHERE t_c.cluster_id = c.id)")};
return execQuery(query, range);
}
Cluster::pointer
Cluster::getById(Session& session, ClusterId id)
Cluster::find(Session& session, ClusterId id)
{
session.checkSharedLocked();
@@ -77,29 +87,15 @@ Cluster::addTrack(ObjectPtr<Track> track)
_tracks.insert(getDboPtr(track));
}
std::vector<Track::pointer>
Cluster::getTracks(std::optional<std::size_t> offset, std::optional<std::size_t> limit) const
RangeResults<TrackId>
Cluster::getTracks(Range range) const
{
assert(session());
auto res {session()->query<Wt::Dbo::ptr<Track>>("SELECT t FROM track t INNER JOIN cluster c ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
.where("c.id = ?").bind(getId())
.offset(offset ? static_cast<int>(*offset) : -1)
.limit(limit ? static_cast<int>(*limit) : -1)
.resultList()};
auto query {session()->query<TrackId>("SELECT t.id FROM track t INNER JOIN cluster c ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
.where("c.id = ?").bind(getId())};
return std::vector<Track::pointer>(res.begin(), res.end());
}
std::vector<TrackId>
Cluster::getTrackIds() const
{
assert(session());
Wt::Dbo::collection<TrackId> res = session()->query<TrackId>("SELECT t_c.track_id FROM track_cluster t_c INNER JOIN cluster c ON c.id = t_c.cluster_id")
.where("c.id = ?").bind(getId());
return std::vector<TrackId>(res.begin(), res.end());
return execQuery(query, range);
}
std::size_t
@@ -117,33 +113,42 @@ ClusterType::ClusterType(std::string_view name)
{
}
std::vector<ClusterType::pointer>
ClusterType::getAllOrphans(Session& session)
std::size_t
ClusterType::getCount(Session& session)
{
session.checkSharedLocked();
Wt::Dbo::collection<Wt::Dbo::ptr<ClusterType>> res = session.getDboSession().query<Wt::Dbo::ptr<ClusterType>>(
"SELECT c_t from cluster_type c_t"
" LEFT OUTER JOIN cluster c ON c_t.id = c.cluster_type_id")
.where("c.id IS NULL");
return std::vector<pointer>(res.begin(), res.end());
return session.getDboSession().query<int>("SELECT COUNT(*) FROM cluster_type");
}
std::vector<ClusterType::pointer>
ClusterType::getAllUsed(Session& session)
RangeResults<ClusterTypeId>
ClusterType::findOrphans(Session& session, Range range)
{
session.checkSharedLocked();
Wt::Dbo::collection<Wt::Dbo::ptr<ClusterType>> res = session.getDboSession().query<Wt::Dbo::ptr<ClusterType>>(
"SELECT DISTINCT c_t from cluster_type c_t")
.join("cluster c ON c_t.id = c.cluster_type_id");
auto query {session.getDboSession().query<ClusterTypeId>(
"SELECT c_t.id from cluster_type c_t"
" LEFT OUTER JOIN cluster c ON c_t.id = c.cluster_type_id")
.where("c.id IS NULL")};
return std::vector<pointer>(res.begin(), res.end());
return execQuery(query, range);
}
RangeResults<ClusterTypeId>
ClusterType::findUsed(Session& session, Range range)
{
session.checkSharedLocked();
auto query {session.getDboSession().query<ClusterTypeId>(
"SELECT DISTINCT c_t.id from cluster_type c_t")
.join("cluster c ON c_t.id = c.cluster_type_id")};
return execQuery(query, range);
}
ClusterType::pointer
ClusterType::getByName(Session& session, const std::string& name)
ClusterType::find(Session& session, const std::string& name)
{
session.checkSharedLocked();
@@ -151,20 +156,21 @@ ClusterType::getByName(Session& session, const std::string& name)
}
ClusterType::pointer
ClusterType::getById(Session& session, ClusterTypeId id)
ClusterType::find(Session& session, ClusterTypeId id)
{
session.checkSharedLocked();
return session.getDboSession().find<ClusterType>().where("id = ?").bind(id).resultValue();
}
std::vector<ClusterType::pointer>
ClusterType::getAll(Session& session)
RangeResults<ClusterTypeId>
ClusterType::find(Session& session, Range range)
{
session.checkSharedLocked();
auto res {session.getDboSession().find<ClusterType>().resultList()};
return std::vector<pointer>(res.begin(), res.end());
auto query {session.getDboSession().query<ClusterTypeId>("SELECT id from cluster_type")};
return execQuery(query, range);
}
ClusterType::pointer
src/libs/services/database/impl/Traits.hpp → src/libs/services/database/impl/IdTypeTraits.hpp
View File
src/libs/services/database/impl/Listen.cpp
+285
View File
@@ -0,0 +1,285 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "services/database/Listen.hpp"
#include "services/database/Session.hpp"
#include "services/database/Track.hpp"
#include "services/database/User.hpp"
#include "IdTypeTraits.hpp"
#include "SqlQuery.hpp"
#include "Utils.hpp"
namespace
{
using namespace Database;
Wt::Dbo::Query<ArtistId>
createArtistsQuery(Wt::Dbo::Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType)
{
auto query {session.query<ArtistId>("SELECT a.id from artist a")
.join("track t ON t.id = t_a_l.track_id")
.join("track_artist_link t_a_l ON t_a_l.artist_id = a.id")
.join("listen l ON l.track_id = t.id")
.where("l.user_id = ?").bind(userId)
.where("l.scrobbler = ?").bind(scrobbler)};
if (linkType)
query.where("t_a_l.type = ?").bind(*linkType);
if (!clusterIds.empty())
{
std::ostringstream oss;
oss << "a.id IN (SELECT DISTINCT a.id FROM artist a"
" INNER JOIN track t ON t.id = t_a_l.track_id"
" INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
" INNER JOIN cluster c ON c.id = t_c.cluster_id"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
WhereClause clusterClause;
for (auto id : clusterIds)
{
clusterClause.Or(WhereClause("c.id = ?"));
query.bind(id);
}
oss << " " << clusterClause.get();
oss << " GROUP BY t.id,a.id HAVING COUNT(DISTINCT c.id) = " << clusterIds.size() << ")";
query.where(oss.str());
}
return query;
}
Wt::Dbo::Query<ReleaseId>
createReleasesQuery(Wt::Dbo::Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds)
{
auto query {session.query<ReleaseId>("SELECT r.id from release r")
.join("track t ON t.release_id = r.id")
.join("listen l ON l.track_id = t.id")
.where("l.user_id = ?").bind(userId)
.where("l.scrobbler = ?").bind(scrobbler)};
if (!clusterIds.empty())
{
std::ostringstream oss;
oss << "r.id IN (SELECT DISTINCT r.id FROM release r"
" INNER JOIN track t ON t.release_id = r.id"
" INNER JOIN cluster c ON c.id = t_c.cluster_id"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
WhereClause clusterClause;
for (ClusterId id : clusterIds)
{
clusterClause.Or(WhereClause("c.id = ?"));
query.bind(id);
}
oss << " " << clusterClause.get();
oss << " GROUP BY t.id HAVING COUNT(DISTINCT c.id) = " << clusterIds.size() << ")";
query.where(oss.str());
}
return query;
}
Wt::Dbo::Query<TrackId>
createTracksQuery(Wt::Dbo::Session& session, UserId userId, Scrobbler scrobbler, const std::vector<ClusterId>& clusterIds)
{
auto query {session.query<TrackId>("SELECT t.id from track t")
.join("listen l ON l.track_id = t.id")
.where("l.user_id = ?").bind(userId)
.where("l.scrobbler = ?").bind(scrobbler)};
if (!clusterIds.empty())
{
std::ostringstream oss;
oss << "t.id IN (SELECT DISTINCT t.id FROM track t"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
" INNER JOIN cluster c ON c.id = t_c.cluster_id";
WhereClause clusterClause;
for (auto id : clusterIds)
{
clusterClause.Or(WhereClause("c.id = ?")).bind(id.toString());
query.bind(id);
}
oss << " " << clusterClause.get();
oss << " GROUP BY t.id HAVING COUNT(*) = " << clusterIds.size() << ")";
query.where(oss.str());
}
return query;
}
}
namespace Database
{
Listen::Listen(ObjectPtr<User> user, ObjectPtr<Track> track, Scrobbler scrobbler, const Wt::WDateTime& dateTime)
: _dateTime {Wt::WDateTime::fromTime_t(dateTime.toTime_t())}
, _scrobbler {scrobbler}
, _user {getDboPtr(user)}
, _track {getDboPtr(track)}
{}
std::size_t
Listen::getCount(Session& session)
{
session.checkSharedLocked();
return session.getDboSession().query<int>("SELECT COUNT(*) FROM listen");
}
Listen::pointer
Listen::find(Session& session, ListenId id)
{
session.checkSharedLocked();
return session.getDboSession().find<Listen>().where("id = ?").bind(id).resultValue();
}
RangeResults<Listen::pointer>
Listen::find(Session& session, UserId userId, Scrobbler scrobbler, Range range)
{
session.checkSharedLocked();
auto query {session.getDboSession().find<Listen>()
.where("user_id = ?").bind(userId)
.where("scrobbler = ?").bind(scrobbler)
.orderBy("date_time")};
return execQuery(query, range);
}
Listen::pointer
Listen::find(Session& session, UserId userId, TrackId trackId, Scrobbler scrobbler, const Wt::WDateTime& dateTime)
{
session.checkSharedLocked();
return session.getDboSession().find<Listen>()
.where("user_id = ?").bind(userId)
.where("track_id = ?").bind(trackId)
.where("scrobbler = ?").bind(scrobbler)
.where("date_time = ?").bind(Wt::WDateTime::fromTime_t(dateTime.toTime_t()))
.resultValue();
}
Listen::pointer
Listen::create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track, Scrobbler scrobbler, const Wt::WDateTime& dateTime)
{
session.checkUniqueLocked();
Listen::pointer res {session.getDboSession().add(std::make_unique<Listen>(user, track, scrobbler, dateTime))};
session.getDboSession().flush();
return res;
}
RangeResults<ArtistId>
Listen::getTopArtists(Session& session,
UserId userId,
Scrobbler scrobbler,
const std::vector<ClusterId>& clusterIds,
std::optional<TrackArtistLinkType> linkType,
Range range)
{
auto query {createArtistsQuery(session.getDboSession(), userId, scrobbler, clusterIds, linkType)};
auto collection {query
.orderBy("COUNT(a.id) DESC")
.groupBy("a.id")};
return execQuery(query, range);
}
RangeResults<ReleaseId>
Listen::getTopReleases(Session& session,
UserId userId,
Scrobbler scrobbler,
const std::vector<ClusterId>& clusterIds,
Range range)
{
auto query {createReleasesQuery(session.getDboSession(), userId, scrobbler, clusterIds)
.orderBy("COUNT(r.id) DESC")
.groupBy("r.id")};
return execQuery(query, range);
}
RangeResults<TrackId>
Listen::getTopTracks(Session& session,
UserId userId,
Scrobbler scrobbler,
const std::vector<ClusterId>& clusterIds,
Range range)
{
auto query {createTracksQuery(session.getDboSession(), userId, scrobbler, clusterIds)
.orderBy("COUNT(t.id) DESC")
.groupBy("t.id")};
return execQuery(query, range);
}
RangeResults<ArtistId>
Listen::getRecentArtists(Session& session,
UserId userId,
Scrobbler scrobbler,
const std::vector<ClusterId>& clusterIds,
std::optional<TrackArtistLinkType> linkType,
Range range)
{
auto query {createArtistsQuery(session.getDboSession(), userId, scrobbler, clusterIds, linkType)
.groupBy("a.id").having("l.date_time = MAX(l.date_time)")
.orderBy("l.date_time DESC")};
return execQuery(query, range);
}
RangeResults<ReleaseId>
Listen::getRecentReleases(Session& session,
UserId userId,
Scrobbler scrobbler,
const std::vector<ClusterId>& clusterIds,
Range range)
{
auto query {createReleasesQuery(session.getDboSession(), userId, scrobbler, clusterIds)
.groupBy("r.id").having("l.date_time = MAX(l.date_time)")
.orderBy("l.date_time DESC")};
return execQuery(query, range);
}
RangeResults<TrackId>
Listen::getRecentTracks(Session& session,
UserId userId,
Scrobbler scrobbler,
const std::vector<ClusterId>& clusterIds,
Range range)
{
auto query {createTracksQuery(session.getDboSession(), userId, scrobbler, clusterIds)
.groupBy("t.id").having("l.date_time = MAX(l.date_time)")
.orderBy("l.date_time DESC")};
return execQuery(query, range);
}
} // namespace Database
src/libs/services/database/impl/Release.cpp
+72 -219
View File
@@ -28,28 +28,45 @@
#include "services/database/User.hpp"
#include "utils/Logger.hpp"
#include "SqlQuery.hpp"
#include "Traits.hpp"
#include "IdTypeTraits.hpp"
#include "Utils.hpp"
namespace Database
{
template <typename T>
static
Wt::Dbo::Query<T>
createQuery(Session& session,
const std::string& queryStr,
const std::vector<ClusterId>& clusterIds,
const std::vector<std::string_view>& keywords)
Wt::Dbo::Query<ReleaseId>
createQuery(Session& session, const Release::FindParameters& params)
{
auto query {session.getDboSession().query<ReleaseId>("SELECT DISTINCT r.id from release r")};
auto query {session.getDboSession().query<T>(queryStr)};
query.join("track t ON t.release_id = r.id");
if (params.sortMethod == ReleaseSortMethod::LastWritten
|| params.writtenAfter.isValid()
|| params.dateRange)
{
query.join("track t ON t.release_id = r.id");
}
for (std::string_view keyword : keywords)
if (params.writtenAfter.isValid())
query.where("t.file_last_write > ?").bind(params.writtenAfter);
if (params.dateRange)
{
query.where("t.date >= ?").bind(params.dateRange->begin);
query.where("t.date <= ?").bind(params.dateRange->end);
}
for (std::string_view keyword : params.keywords)
query.where("r.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'").bind("%" + escapeLikeKeyword(keyword) + "%");
if (!clusterIds.empty())
if (params.starringUser.isValid())
{
assert(params.scrobbler);
query.join("starred_release s_r ON s_r.release_id = r.id")
.where("s_r.user_id = ?").bind(params.starringUser)
.where("s_r.scrobbler = ?").bind(*params.scrobbler);
}
if (!params.clusters.empty())
{
std::ostringstream oss;
oss << "r.id IN (SELECT DISTINCT r.id FROM release r"
@@ -58,18 +75,40 @@ createQuery(Session& session,
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
WhereClause clusterClause;
for (const ClusterId clusterId : clusterIds)
for (const ClusterId clusterId : params.clusters)
{
clusterClause.Or(WhereClause("c.id = ?"));
query.bind(clusterId);
}
oss << " " << clusterClause.get();
oss << " GROUP BY t.id HAVING COUNT(*) = " << clusterIds.size() << ")";
oss << " GROUP BY t.id HAVING COUNT(*) = " << params.clusters.size() << ")";
query.where(oss.str());
}
switch (params.sortMethod)
{
case ReleaseSortMethod::None:
break;
case ReleaseSortMethod::Name:
query.orderBy("r.name COLLATE NOCASE");
break;
case ReleaseSortMethod::Random:
query.orderBy("RANDOM()");
break;
case ReleaseSortMethod::LastWritten:
query.orderBy("t.file_last_write DESC");
break;
case ReleaseSortMethod::Date:
query.orderBy("t.date, r.name COLLATE NOCASE");
break;
case ReleaseSortMethod::StarredDateDesc:
assert(params.starringUser.isValid());
query.orderBy("s_r.date_time DESC");
break;
}
return query;
}
@@ -80,7 +119,7 @@ _MBID {MBID ? MBID->getAsString() : ""}
}
std::vector<Release::pointer>
Release::getByName(Session& session, const std::string& name)
Release::find(Session& session, const std::string& name)
{
session.checkUniqueLocked();
@@ -93,7 +132,7 @@ Release::getByName(Session& session, const std::string& name)
}
Release::pointer
Release::getByMBID(Session& session, const UUID& mbid)
Release::find(Session& session, const UUID& mbid)
{
session.checkSharedLocked();
@@ -104,7 +143,7 @@ Release::getByMBID(Session& session, const UUID& mbid)
}
Release::pointer
Release::getById(Session& session, ReleaseId id)
Release::find(Session& session, ReleaseId id)
{
session.checkSharedLocked();
@@ -137,230 +176,44 @@ Release::getCount(Session& session)
{
session.checkSharedLocked();
return session.getDboSession().find<Release>().resultList().size();
return session.getDboSession().query<int>("SELECT COUNT(*) FROM release");
}
std::vector<Release::pointer>
Release::getAll(Session& session, std::optional<Range> range)
RangeResults<ReleaseId>
Release::findOrderedByArtist(Session& session, Range range)
{
session.checkSharedLocked();
auto res {session.getDboSession().find<Release>()
.offset(range ? static_cast<int>(range->offset) : -1)
.limit(range ? static_cast<int>(range->limit) : -1)
.orderBy("name COLLATE NOCASE")
.resultList()};
return std::vector<pointer>(res.begin(), res.end());
}
std::vector<ReleaseId>
Release::getAllIds(Session& session)
{
session.checkSharedLocked();
Wt::Dbo::collection<ReleaseId> res = session.getDboSession().query<ReleaseId>("SELECT id FROM release");
return std::vector<ReleaseId>(res.begin(), res.end());
}
std::vector<Release::pointer>
Release::getAllOrderedByArtist(Session& session, std::optional<std::size_t> offset, std::optional<std::size_t> size)
{
session.checkSharedLocked();
auto res {session.getDboSession().query<Wt::Dbo::ptr<Release>>(
"SELECT DISTINCT r FROM release r"
// TODO merge with execQuery
auto query {session.getDboSession().query<ReleaseId>(
"SELECT DISTINCT r.id FROM release r"
" INNER JOIN track t ON r.id = t.release_id"
" INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id"
" INNER JOIN artist a ON t_a_l.artist_id = a.id")
.offset(offset ? static_cast<int>(*offset) : -1)
.limit(size ? static_cast<int>(*size) : -1)
.orderBy("a.name COLLATE NOCASE, r.name COLLATE NOCASE")
.resultList()};
.orderBy("a.name COLLATE NOCASE, r.name COLLATE NOCASE")};
return std::vector<pointer>(res.begin(), res.end());
return execQuery(query, range);
}
std::vector<Release::pointer>
Release::getAllRandom(Session& session, const std::vector<ClusterId>& clusterIds, std::optional<std::size_t> size)
RangeResults<ReleaseId>
Release::findOrphans(Session& session, Range range)
{
session.checkSharedLocked();
auto query {createQuery<Wt::Dbo::ptr<Release>>(session, "SELECT DISTINCT r from release r", clusterIds, {})};
auto res {query
.orderBy("RANDOM()")
.limit(size ? static_cast<int>(*size) : -1)
.resultList()};
return std::vector<pointer>(res.begin(), res.end());
auto query {session.getDboSession().query<ReleaseId>("select r.id from release r LEFT OUTER JOIN Track t ON r.id = t.release_id WHERE t.id IS NULL")};
return execQuery(query, range);
}
std::vector<ReleaseId>
Release::getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusterIds, std::optional<std::size_t> size)
RangeResults<ReleaseId>
Release::find(Session& session, const FindParameters& params)
{
session.checkSharedLocked();
auto query {createQuery<ReleaseId>(session, "SELECT DISTINCT r.id from release r", clusterIds, {})};
auto query {createQuery(session, params)};
Wt::Dbo::collection<ReleaseId> res = query
.orderBy("RANDOM()")
.limit(size ? static_cast<int>(*size) : -1);
return std::vector<ReleaseId>(res.begin(), res.end());
return execQuery(query, params.range);
}
std::vector<Release::pointer>
Release::getAllOrphans(Session& session)
{
session.checkSharedLocked();
auto res {session.getDboSession().query<Wt::Dbo::ptr<Release>>("select r from release r LEFT OUTER JOIN Track t ON r.id = t.release_id WHERE t.id IS NULL").resultList()};
return std::vector<pointer>(res.begin(), res.end());
}
std::vector<Release::pointer>
Release::getLastWritten(Session& session,
std::optional<Wt::WDateTime> after,
const std::vector<ClusterId>& clusterIds,
std::optional<Range> range,
bool& moreResults)
{
session.checkSharedLocked();
auto query {createQuery<Wt::Dbo::ptr<Release>>(session, "SELECT r from release r", clusterIds, {})};
if (after)
query.where("t.file_last_write > ?").bind(after);
auto collection {query
.orderBy("t.file_last_write DESC")
.groupBy("r.id")
.offset(range ? static_cast<int>(range->offset) : -1)
.limit(range ? static_cast<int>(range->limit) + 1: -1)
.resultList()};
std::vector<pointer> res(collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return res;
}
std::vector<Release::pointer>
Release::getByYear(Session& session, int yearFrom, int yearTo, std::optional<Range> range)
{
auto res {session.getDboSession().query<Wt::Dbo::ptr<Release>>
("SELECT DISTINCT r from release r INNER JOIN track t ON r.id = t.release_id")
.where("t.date >= ?").bind(Wt::WDate {yearFrom, 1, 1})
.where("t.date <= ?").bind(Wt::WDate {yearTo, 12, 31})
.orderBy("t.date, r.name COLLATE NOCASE")
.offset(range ? static_cast<int>(range->offset) : -1)
.limit(range ? static_cast<int>(range->limit) : -1)
.resultList()};
return std::vector<pointer>(res.begin(), res.end());
}
std::vector<Release::pointer>
Release::getStarred(Session& session,
User::pointer user,
const std::vector<ClusterId>& clusterIds,
std::optional<Range> range,
bool& moreResults)
{
session.checkSharedLocked();
auto query {createQuery<Wt::Dbo::ptr<Release>>(session, "SELECT r from release r", clusterIds, {})};
{
std::ostringstream oss;
oss << "r.id IN (SELECT DISTINCT r.id FROM release r"
" INNER JOIN user_release_starred urs ON urs.release_id = r.id"
" INNER JOIN user u ON u.id = urs.user_id WHERE u.id = ?)";
query.bind(user->getId());
query.where(oss.str());
}
auto collection {query
.groupBy("r.id")
.orderBy("r.name COLLATE NOCASE")
.offset(range ? static_cast<int>(range->offset) : -1)
.limit(range ? static_cast<int>(range->limit) + 1: -1)
.resultList()};
std::vector<pointer> res(collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return res;
}
std::vector<Release::pointer>
Release::getByClusters(Session& session, const std::vector<ClusterId>& clusters)
{
assert(!clusters.empty());
session.checkSharedLocked();
bool moreResults;
return getByFilter(session, clusters, {}, std::nullopt, moreResults);
}
std::vector<Release::pointer>
Release::getByFilter(Session& session,
const std::vector<ClusterId>& clusterIds,
const std::vector<std::string_view>& keywords,
std::optional<Range> range,
bool& moreResults)
{
session.checkSharedLocked();
auto collection {createQuery<Wt::Dbo::ptr<Release>>(session, "SELECT r from release r", clusterIds, keywords)
.groupBy("r.id")
.orderBy("r.name COLLATE NOCASE")
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1)
.resultList()};
std::vector<pointer> res(collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return res;
}
std::vector<ReleaseId>
Release::getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit)
{
session.checkSharedLocked();
Wt::Dbo::collection<ReleaseId> res = session.getDboSession().query<ReleaseId>
("SELECT DISTINCT r.id FROM release r"
" INNER JOIN track t ON t.release_id = r.id"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
.limit(limit ? static_cast<int>(*limit) : -1);
return std::vector<ReleaseId>(res.begin(), res.end());
}
std::optional<std::size_t>
Release::getTotalTrack(void) const
{
src/libs/services/database/impl/ScanSettings.cpp
+1 -1
View File
@@ -111,7 +111,7 @@ ScanSettings::setClusterTypes(Session& session, const std::set<std::string>& clu
// Create any missing cluster type
for (const std::string& clusterTypeName : clusterTypeNames)
{
ClusterType::pointer clusterType {ClusterType::getByName(session, clusterTypeName)};
ClusterType::pointer clusterType {ClusterType::find(session, clusterTypeName)};
if (!clusterType)
{
LMS_LOG(DB, INFO) << "Creating cluster type " << clusterTypeName;
src/libs/services/database/impl/Session.cpp
+70 -1
View File
@@ -28,10 +28,15 @@
#include "utils/Logger.hpp"
#include "services/database/Artist.hpp"
#include "services/database/AuthToken.hpp"
#include "services/database/Cluster.hpp"
#include "services/database/Db.hpp"
#include "services/database/Listen.hpp"
#include "services/database/Release.hpp"
#include "services/database/ScanSettings.hpp"
#include "services/database/StarredArtist.hpp"
#include "services/database/StarredRelease.hpp"
#include "services/database/StarredTrack.hpp"
#include "services/database/Track.hpp"
#include "services/database/TrackBookmark.hpp"
#include "services/database/TrackArtistLink.hpp"
@@ -43,7 +48,7 @@ namespace Database
{
using Version = std::size_t;
static constexpr Version LMS_DATABASE_VERSION {31};
static constexpr Version LMS_DATABASE_VERSION {32};
class VersionInfo
{
@@ -360,6 +365,61 @@ CREATE TABLE "track_backup" (
// Just increment the scan version of the settings to make the next scheduled scan rescan everything
ScanSettings::get(*this).modify()->incScanVersion();
}
else if (version == 31)
{
// new star system, using dedicated ObjectSets per scrobbler
_session.execute("DROP TABLE user_artist_starred");
_session.execute("DROP TABLE user_release_starred");
_session.execute("DROP TABLE user_track_starred");
_session.execute(R"(
CREATE TABLE IF NOT EXISTS "starred_artist" (
"id" integer primary key autoincrement,
"version" integer not null,
"scrobbler" integer not null,
"date_time" text,
"artist_id" bigint,
"user_id" bigint,
constraint "fk_starred_artist_artist" foreign key ("artist_id") references "artist" ("id") on delete cascade deferrable initially deferred,
constraint "fk_starred_artist_user" foreign key ("user_id") references "user" ("id") on delete cascade deferrable initially deferred
))");
_session.execute(R"(
CREATE TABLE IF NOT EXISTS "starred_release" (
"id" integer primary key autoincrement,
"version" integer not null,
"scrobbler" integer not null,
"date_time" text,
"release_id" bigint,
"user_id" bigint,
constraint "fk_starred_release_release" foreign key ("release_id") references "release" ("id") on delete cascade deferrable initially deferred,
constraint "fk_starred_release_user" foreign key ("user_id") references "user" ("id") on delete cascade deferrable initially deferred
))");
_session.execute(R"(
CREATE TABLE IF NOT EXISTS "starred_track" (
"id" integer primary key autoincrement,
"version" integer not null,
"scrobbler" integer not null,
"date_time" text,
"track_id" bigint,
"user_id" bigint,
constraint "fk_starred_track_track" foreign key ("track_id") references "track" ("id") on delete cascade deferrable initially deferred,
constraint "fk_starred_track_user" foreign key ("user_id") references "user" ("id") on delete cascade deferrable initially deferred
))");
_session.execute(R"(
CREATE TABLE IF NOT EXISTS "listen" (
"id" integer primary key autoincrement,
"version" integer not null,
"date_time" text,
"scrobbler" integer not null,
"track_id" bigint,
"user_id" bigint,
constraint "fk_listen_track" foreign key ("track_id") references "track" ("id") on delete cascade deferrable initially deferred,
constraint "fk_listen_user" foreign key ("user_id") references "user" ("id") on delete cascade deferrable initially deferred
))");
}
else
{
LMS_LOG(DB, ERROR) << "Database version " << version << " cannot be handled using migration";
@@ -380,8 +440,12 @@ Session::Session(Db& db)
_session.mapClass<AuthToken>("auth_token");
_session.mapClass<Cluster>("cluster");
_session.mapClass<ClusterType>("cluster_type");
_session.mapClass<Listen>("listen");
_session.mapClass<Release>("release");
_session.mapClass<ScanSettings>("scan_settings");
_session.mapClass<StarredArtist>("starred_artist");
_session.mapClass<StarredRelease>("starred_release");
_session.mapClass<StarredTrack>("starred_track");
_session.mapClass<Track>("track");
_session.mapClass<TrackBookmark>("track_bookmark");
_session.mapClass<TrackArtistLink>("track_artist_link");
@@ -484,6 +548,11 @@ Session::prepareTables()
_session.execute("CREATE INDEX IF NOT EXISTS track_artist_link_type_idx ON track_artist_link(type)");
_session.execute("CREATE INDEX IF NOT EXISTS track_bookmark_user_idx ON track_bookmark(user_id)");
_session.execute("CREATE INDEX IF NOT EXISTS track_bookmark_user_track_idx ON track_bookmark(user_id,track_id)");
_session.execute("CREATE INDEX IF NOT EXISTS listen_scrobbler_idx ON listen(scrobbler)");
_session.execute("CREATE INDEX IF NOT EXISTS listen_user_scrobbler_idx ON listen(user_id,scrobbler)");
_session.execute("CREATE INDEX IF NOT EXISTS starred_artist_user_scrobbler_idx ON starred_artist(user_id,scrobbler)");
_session.execute("CREATE INDEX IF NOT EXISTS starred_release_user_scrobbler_idx ON starred_release(user_id,scrobbler)");
_session.execute("CREATE INDEX IF NOT EXISTS starred_track_user_scrobbler_idx ON starred_track(user_id,scrobbler)");
}
// Initial settings tables
src/libs/services/database/impl/StarredArtist.cpp
+79
View File
@@ -0,0 +1,79 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "services/database/StarredArtist.hpp"
#include <Wt/Dbo/WtSqlTraits.h>
#include "services/database/Artist.hpp"
#include "services/database/User.hpp"
#include "IdTypeTraits.hpp"
#include "Utils.hpp"
namespace Database
{
StarredArtist::StarredArtist(ObjectPtr<Artist> artist, ObjectPtr<User> user, Scrobbler scrobbler)
: _scrobbler {scrobbler}
, _artist {getDboPtr(artist)}
, _user {getDboPtr(user)}
{
}
std::size_t
StarredArtist::getCount(Session& session)
{
session.checkSharedLocked();
return session.getDboSession().query<int>("SELECT COUNT(*) FROM starred_artist");
}
StarredArtist::pointer
StarredArtist::find(Session& session, StarredArtistId id)
{
session.checkSharedLocked();
return session.getDboSession().find<StarredArtist>().where("id = ?").bind(id).resultValue();
}
StarredArtist::pointer
StarredArtist::find(Session& session, ArtistId artistId, UserId userId, Scrobbler scrobbler)
{
session.checkSharedLocked();
return session.getDboSession().find<StarredArtist>()
.where("artist_id = ?").bind(artistId)
.where("user_id = ?").bind(userId)
.where("scrobbler = ?").bind(scrobbler)
.resultValue();
}
StarredArtist::pointer
StarredArtist::create(Session& session, ObjectPtr<Artist> artist, ObjectPtr<User> user, Scrobbler scrobbler)
{
session.checkUniqueLocked();
StarredArtist::pointer res {session.getDboSession().add(std::make_unique<StarredArtist>(artist, user, scrobbler))};
session.getDboSession().flush();
return res;
}
void
StarredArtist::setDateTime(const Wt::WDateTime& dateTime)
{
_dateTime = normalizeDateTime(dateTime);
}
}
src/libs/services/database/impl/StarredRelease.cpp
+79
View File
@@ -0,0 +1,79 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "services/database/StarredRelease.hpp"
#include <Wt/Dbo/WtSqlTraits.h>
#include "services/database/Release.hpp"
#include "services/database/User.hpp"
#include "IdTypeTraits.hpp"
#include "Utils.hpp"
namespace Database
{
StarredRelease::StarredRelease(ObjectPtr<Release> release, ObjectPtr<User> user, Scrobbler scrobbler)
: _scrobbler {scrobbler}
, _release {getDboPtr(release)}
, _user {getDboPtr(user)}
{
}
std::size_t
StarredRelease::getCount(Session& session)
{
session.checkSharedLocked();
return session.getDboSession().query<int>("SELECT COUNT(*) FROM starred_release");
}
StarredRelease::pointer
StarredRelease::find(Session& session, StarredReleaseId id)
{
session.checkSharedLocked();
return session.getDboSession().find<StarredRelease>().where("id = ?").bind(id).resultValue();
}
StarredRelease::pointer
StarredRelease::find(Session& session, ReleaseId releaseId, UserId userId, Scrobbler scrobbler)
{
session.checkSharedLocked();
return session.getDboSession().find<StarredRelease>()
.where("release_id = ?").bind(releaseId)
.where("user_id = ?").bind(userId)
.where("scrobbler = ?").bind(scrobbler)
.resultValue();
}
StarredRelease::pointer
StarredRelease::create(Session& session, ObjectPtr<Release> release, ObjectPtr<User> user, Scrobbler scrobbler)
{
session.checkUniqueLocked();
StarredRelease::pointer res {session.getDboSession().add(std::make_unique<StarredRelease>(release, user, scrobbler))};
session.getDboSession().flush();
return res;
}
void
StarredRelease::setDateTime(const Wt::WDateTime& dateTime)
{
_dateTime = normalizeDateTime(dateTime);
}
}
src/libs/services/database/impl/StarredTrack.cpp
+79
View File
@@ -0,0 +1,79 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "services/database/StarredTrack.hpp"
#include <Wt/Dbo/WtSqlTraits.h>
#include "services/database/Track.hpp"
#include "services/database/User.hpp"
#include "IdTypeTraits.hpp"
#include "Utils.hpp"
namespace Database
{
StarredTrack::StarredTrack(ObjectPtr<Track> track, ObjectPtr<User> user, Scrobbler scrobbler)
: _scrobbler {scrobbler}
, _track {getDboPtr(track)}
, _user {getDboPtr(user)}
{
}
std::size_t
StarredTrack::getCount(Session& session)
{
session.checkSharedLocked();
return session.getDboSession().query<int>("SELECT COUNT(*) FROM starred_track");
}
StarredTrack::pointer
StarredTrack::find(Session& session, StarredTrackId id)
{
session.checkSharedLocked();
return session.getDboSession().find<StarredTrack>().where("id = ?").bind(id).resultValue();
}
StarredTrack::pointer
StarredTrack::find(Session& session, TrackId trackId, UserId userId, Scrobbler scrobbler)
{
session.checkSharedLocked();
return session.getDboSession().find<StarredTrack>()
.where("track_id = ?").bind(trackId)
.where("user_id = ?").bind(userId)
.where("scrobbler = ?").bind(scrobbler)
.resultValue();
}
StarredTrack::pointer
StarredTrack::create(Session& session, ObjectPtr<Track> track, ObjectPtr<User> user, Scrobbler scrobbler)
{
session.checkUniqueLocked();
StarredTrack::pointer res {session.getDboSession().add(std::make_unique<StarredTrack>(track, user, scrobbler))};
session.getDboSession().flush();
return res;
}
void
StarredTrack::setDateTime(const Wt::WDateTime& dateTime)
{
_dateTime = normalizeDateTime(dateTime);
}
}
src/libs/services/database/impl/Track.cpp
+93 -262
View File
@@ -30,29 +30,36 @@
#include "services/database/User.hpp"
#include "utils/Logger.hpp"
#include "IdTypeTraits.hpp"
#include "SqlQuery.hpp"
#include "StringViewTraits.hpp"
#include "Traits.hpp"
#include "Utils.hpp"
namespace Database {
template <typename T>
static
Wt::Dbo::Query<T>
createQuery(Session& session,
const std::string& queryStr,
const std::vector<ClusterId>& clusterIds,
const std::vector<std::string_view>& keywords)
Wt::Dbo::Query<TrackId>
createQuery(Session& session, const Track::FindParameters& params)
{
session.checkSharedLocked();
auto query {session.getDboSession().query<T>(queryStr)};
auto query {session.getDboSession().query<TrackId>("SELECT t.id from track t")};
for (std::string_view keyword : keywords)
for (std::string_view keyword : params.keywords)
query.where("t.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'").bind("%" + escapeLikeKeyword(keyword) + "%");
if (!clusterIds.empty())
if (params.writtenAfter.isValid())
query.where("t.file_last_write > ?").bind(params.writtenAfter);
if (params.starringUser.isValid())
{
assert(params.scrobbler);
query.join("starred_track s_t ON s_t.track_id = t.id")
.where("s_t.user_id = ?").bind(params.starringUser)
.where("s_t.scrobbler = ?").bind(*params.scrobbler);
}
if (!params.clusters.empty())
{
std::ostringstream oss;
oss << "t.id IN (SELECT DISTINCT t.id FROM track t"
@@ -60,18 +67,34 @@ createQuery(Session& session,
" INNER JOIN cluster c ON c.id = t_c.cluster_id";
WhereClause clusterClause;
for (const ClusterId clusterId : clusterIds)
for (const ClusterId clusterId : params.clusters)
{
clusterClause.Or(WhereClause("c.id = ?"));
query.bind(clusterId);
}
oss << " " << clusterClause.get();
oss << " GROUP BY t.id HAVING COUNT(*) = " << clusterIds.size() << ")";
oss << " GROUP BY t.id HAVING COUNT(*) = " << params.clusters.size() << ")";
query.where(oss.str());
}
switch (params.sortMethod)
{
case TrackSortMethod::None:
break;
case TrackSortMethod::LastWritten:
query.orderBy("t.file_last_write DESC");
break;
case TrackSortMethod::Random:
query.orderBy("RANDOM()");
break;
case TrackSortMethod::StarredDateDesc:
assert(params.starringUser.isValid());
query.orderBy("s_t.date_time DESC");
break;
}
return query;
}
@@ -80,6 +103,17 @@ Track::Track(const std::filesystem::path& p)
{
}
Track::pointer
Track::create(Session& session, const std::filesystem::path& p)
{
session.checkUniqueLocked();
Track::pointer res {session.getDboSession().add(std::make_unique<Track>(p))};
session.getDboSession().flush();
return res;
}
std::size_t
Track::getCount(Session& session)
{
@@ -88,58 +122,8 @@ Track::getCount(Session& session)
return session.getDboSession().query<int>("SELECT COUNT(*) FROM track");
}
std::vector<Track::pointer>
Track::getAll(Session& session, std::optional<std::size_t> limit)
{
session.checkSharedLocked();
auto res {session.getDboSession().find<Track>()
.limit(limit ? static_cast<int>(*limit) : -1)
.resultList()};
return std::vector<Track::pointer>(std::cbegin(res), std::cend(res));
}
std::vector<Track::pointer>
Track::getAllRandom(Session& session, const std::vector<ClusterId>& clusterIds, std::optional<std::size_t> limit)
{
session.checkSharedLocked();
auto query {createQuery<Wt::Dbo::ptr<Track>>(session, "SELECT t from track t", clusterIds, {})};
auto collection {query
.orderBy("RANDOM()")
.limit(limit ? static_cast<int>(*limit) + 1: -1)
.resultList()};
return std::vector<pointer>(collection.begin(), collection.end());
}
std::vector<TrackId>
Track::getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusterIds, std::optional<std::size_t> limit)
{
session.checkSharedLocked();
auto query {createQuery<TrackId>(session, "SELECT t.id from track t", clusterIds, {})};
Wt::Dbo::collection<TrackId> collection = query
.orderBy("RANDOM()")
.limit(limit ? static_cast<int>(*limit) + 1: -1);
return std::vector<TrackId>(collection.begin(), collection.end());
}
std::vector<TrackId>
Track::getAllIds(Session& session)
{
session.checkSharedLocked();
Wt::Dbo::collection<TrackId> res = session.getDboSession().query<TrackId>("SELECT id FROM track");
return std::vector<TrackId>(res.begin(), res.end());
}
Track::pointer
Track::getByPath(Session& session, const std::filesystem::path& p)
Track::findByPath(Session& session, const std::filesystem::path& p)
{
session.checkSharedLocked();
@@ -147,7 +131,7 @@ Track::getByPath(Session& session, const std::filesystem::path& p)
}
Track::pointer
Track::getById(Session& session, TrackId id)
Track::find(Session& session, TrackId id)
{
session.checkSharedLocked();
@@ -165,7 +149,7 @@ Track::exists(Session& session, TrackId id)
}
std::vector<Track::pointer>
Track::getByRecordingMBID(Session& session, const UUID& mbid)
Track::findByRecordingMBID(Session& session, const UUID& mbid)
{
session.checkSharedLocked();
@@ -176,151 +160,52 @@ Track::getByRecordingMBID(Session& session, const UUID& mbid)
return std::vector<Track::pointer>(res.begin(), res.end());
}
Track::pointer
Track::create(Session& session, const std::filesystem::path& p)
{
session.checkUniqueLocked();
Track::pointer res {session.getDboSession().add(std::make_unique<Track>(p))};
session.getDboSession().flush();
return res;
}
std::vector<std::pair<TrackId, std::filesystem::path>>
Track::getAllPaths(Session& session, std::optional<std::size_t> offset, std::optional<std::size_t> size)
RangeResults<Track::PathResult>
Track::findPaths(Session& session, Range range)
{
using QueryResultType = std::tuple<TrackId, std::string>;
session.checkSharedLocked();
Wt::Dbo::collection<QueryResultType> queryRes = session.getDboSession().query<QueryResultType>("SELECT id,file_path FROM track")
.limit(size ? static_cast<int>(*size) + 1 : -1)
.offset(offset ? static_cast<int>(*offset) : -1);
// TODO Dbo traits on filesystem
auto query {session.getDboSession().query<QueryResultType>("SELECT id, file_path FROM track")};
std::vector<std::pair<TrackId, std::filesystem::path>> result;
result.reserve(queryRes.size());
RangeResults<QueryResultType> queryResults {execQuery(query, range)};
std::transform(std::begin(queryRes), std::end(queryRes), std::back_inserter(result),
RangeResults<PathResult> res;
res.range = queryResults.range;
res.moreResults = queryResults.moreResults;
res.results.reserve(queryResults.results.size());
std::transform(std::cbegin(queryResults.results), std::cend(queryResults.results), std::back_inserter(res.results),
[](const QueryResultType& queryResult)
{
return std::make_pair(std::get<0>(queryResult), std::get<1>(queryResult));
return PathResult {std::get<0>(queryResult), std::get<1>(queryResult)};
});
return result;
}
std::vector<Track::pointer>
Track::getMBIDDuplicates(Session& session)
{
session.checkSharedLocked();
auto res {session.getDboSession().query<Wt::Dbo::ptr<Track>>( "SELECT track FROM track WHERE mbid in (SELECT mbid FROM track WHERE mbid <> '' GROUP BY mbid HAVING COUNT (*) > 1)")
.orderBy("track.release_id,track.disc_number,track.track_number,track.mbid")
.resultList()};
return std::vector<pointer>(res.begin(), res.end());
}
std::vector<Track::pointer>
Track::getLastWritten(Session& session, std::optional<Wt::WDateTime> after, const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults)
{
session.checkSharedLocked();
auto query {createQuery<Wt::Dbo::ptr<Track>>(session, "SELECT t from track t", clusterIds, {})};
if (after)
query.where("t.file_last_write > ?").bind(after);
auto collection {query
.orderBy("t.file_last_write DESC")
.groupBy("t.id")
.offset(range ? static_cast<int>(range->offset) : -1)
.limit(range ? static_cast<int>(range->limit) + 1: -1)
.resultList()};
std::vector<pointer> res(collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return res;
}
std::vector<Track::pointer>
Track::getAllWithRecordingMBIDAndMissingFeatures(Session& session)
RangeResults<TrackId>
Track::findMBIDDuplicates(Session& session, Range range)
{
session.checkSharedLocked();
auto res {session.getDboSession().query<Wt::Dbo::ptr<Track>>
("SELECT t FROM track t")
auto query {session.getDboSession().query<TrackId>( "SELECT track.id FROM track WHERE mbid in (SELECT mbid FROM track WHERE mbid <> '' GROUP BY mbid HAVING COUNT (*) > 1)")
.orderBy("track.release_id,track.disc_number,track.track_number,track.mbid")};
return execQuery(query, range);
}
RangeResults<TrackId>
Track::findWithRecordingMBIDAndMissingFeatures(Session& session, Range range)
{
session.checkSharedLocked();
auto query {session.getDboSession().query<TrackId>("SELECT t.id FROM track t")
.where("LENGTH(t.recording_mbid) > 0")
.where("NOT EXISTS (SELECT * FROM track_features t_f WHERE t_f.track_id = t.id)")
.resultList()};
return std::vector<pointer>(res.begin(), res.end());
}
.where("NOT EXISTS (SELECT * FROM track_features t_f WHERE t_f.track_id = t.id)")};
std::vector<TrackId>
Track::getAllIdsWithFeatures(Session& session, std::optional<std::size_t> limit)
{
session.checkSharedLocked();
Wt::Dbo::collection<TrackId> res = session.getDboSession().query<TrackId>
("SELECT t.id FROM track t")
.where("EXISTS (SELECT * from track_features t_f WHERE t_f.track_id = t.id)")
.limit(limit ? static_cast<int>(*limit) : -1);
return std::vector<TrackId>(res.begin(), res.end());
}
std::vector<TrackId>
Track::getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit)
{
session.checkSharedLocked();
Wt::Dbo::collection<TrackId> res = session.getDboSession().query<TrackId>
("SELECT DISTINCT t.id FROM track t"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
.limit(limit ? static_cast<int>(*limit) : -1);
return std::vector<TrackId>(res.begin(), res.end());
}
std::vector<Track::pointer>
Track::getStarred(Session& session,
ObjectPtr<User> user,
const std::vector<ClusterId>& clusterIds,
std::optional<Range> range, bool& moreResults)
{
session.checkSharedLocked();
auto query {createQuery<Wt::Dbo::ptr<Track>>(session, "SELECT t from track t", clusterIds, {})};
{
std::ostringstream oss;
oss << "t.id IN (SELECT DISTINCT t.id FROM track t"
" INNER JOIN user_track_starred uts ON uts.track_id = t.id"
" INNER JOIN user u ON u.id = uts.user_id WHERE u.id = ?)";
query.bind(user->getId().toString());
query.where(oss.str());
}
auto collection {query
.offset(range ? static_cast<int>(range->offset) : -1)
.limit(range ? static_cast<int>(range->limit) + 1: -1)
.resultList()};
std::vector<pointer> res(collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return res;
return execQuery(query, range);
}
std::vector<Cluster::pointer>
@@ -342,56 +227,31 @@ Track::getClusterIds() const
return std::vector<ClusterId>(res.begin(), res.end());
}
bool
Track::hasTrackFeatures() const
{
return (_trackFeatures.lock() != Wt::Dbo::ptr<Database::TrackFeatures> {});
}
std::vector<Track::pointer>
Track::getByFilter(Session& session,
const std::vector<ClusterId>& clusterIds,
const std::vector<std::string_view>& keywords,
std::optional<Range> range,
bool& moreResults)
RangeResults<TrackId>
Track::find(Session& session, const FindParameters& parameters)
{
session.checkSharedLocked();
auto collection {createQuery<Wt::Dbo::ptr<Track>>(session, "SELECT t from track t", clusterIds, keywords)
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1)
.resultList()};
auto query {createQuery(session, parameters)};
std::vector<pointer> res(collection.begin(), collection.end());
if (range && (res.size() == static_cast<std::size_t>(range->limit) + 1))
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return res;
return execQuery(query, parameters.range);
}
std::vector<Track::pointer>
Track::getByNameAndReleaseName(Session& session, std::string_view trackName, std::string_view releaseName)
RangeResults<TrackId>
Track::findByNameAndReleaseName(Session& session, std::string_view trackName, std::string_view releaseName)
{
session.checkSharedLocked();
auto res {session.getDboSession().query<Wt::Dbo::ptr<Track>>("SELECT t from track t")
auto query {session.getDboSession().query<TrackId>("SELECT t.id from track t")
.join("release r ON t.release_id = r.id")
.where("t.name = ?").bind(trackName)
.where("r.name = ?").bind(releaseName)
.resultList()};
return std::vector<pointer>(res.begin(), res.end());
.where("r.name = ?").bind(releaseName)};
return execQuery(query, Range {});
}
std::vector<Track::pointer>
Track::getSimilarTracks(Session& session,
const std::vector<TrackId>& tracks,
std::optional<std::size_t> offset,
std::optional<std::size_t> size)
RangeResults<TrackId>
Track::findSimilarTracks(Session& session, const std::vector<TrackId>& tracks, Range range)
{
assert(!tracks.empty());
session.checkSharedLocked();
@@ -404,15 +264,13 @@ Track::getSimilarTracks(Session& session,
oss << "?";
}
auto query {session.getDboSession().query<Wt::Dbo::ptr<Track>>(
"SELECT t FROM track t"
auto query {session.getDboSession().query<TrackId>(
"SELECT t.id FROM track t"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
" AND t_c.cluster_id IN (SELECT c.id FROM cluster c INNER JOIN track_cluster t_c ON t_c.cluster_id = c.id WHERE t_c.track_id IN (" + oss.str() + "))"
" AND t.id NOT IN (" + oss.str() + ")")
.groupBy("t.id")
.orderBy("COUNT(*) DESC, RANDOM()")
.limit(size ? static_cast<int>(*size) : -1)
.offset(offset ? static_cast<int>(*offset) : -1)};
.orderBy("COUNT(*) DESC, RANDOM()")};
for (TrackId trackId : tracks)
query.bind(trackId);
@@ -420,22 +278,7 @@ Track::getSimilarTracks(Session& session,
for (TrackId trackId : tracks)
query.bind(trackId);
auto res {query.resultList()};
return std::vector<pointer>(res.begin(), res.end());
}
std::vector<Track::pointer>
Track::getByClusters(Session& session, const std::vector<ClusterId>& clusters)
{
assert(!clusters.empty());
session.checkSharedLocked();
bool moreResults;
return getByFilter(session,
clusters,
{}, // keywords
std::nullopt, // range
moreResults);
return execQuery(query, range);
}
void
@@ -458,12 +301,6 @@ Track::setClusters(const std::vector<ObjectPtr<Cluster>>& clusters)
_clusters.insert(getDboPtr(cluster));
}
void
Track::setFeatures(const ObjectPtr<TrackFeatures>& features)
{
_trackFeatures = getDboPtr(features);
}
std::optional<std::size_t>
Track::getTrackNumber() const
{
@@ -593,12 +430,6 @@ Track::getArtistLinks() const
return std::vector<TrackArtistLink::pointer>(_trackArtistLinks.begin(), _trackArtistLinks.end());
}
ObjectPtr<TrackFeatures>
Track::getTrackFeatures() const
{
return _trackFeatures.lock();
}
std::vector<std::vector<Cluster::pointer>>
Track::getClusterGroups(const std::vector<ClusterType::pointer>& clusterTypes, std::size_t size) const
{
src/libs/services/database/impl/TrackArtistLink.cpp
+2 -2
View File
@@ -23,7 +23,7 @@
#include "services/database/Session.hpp"
#include "services/database/Track.hpp"
#include "Traits.hpp"
#include "IdTypeTraits.hpp"
namespace Database {
@@ -46,7 +46,7 @@ TrackArtistLink::create(Session& session, ObjectPtr<Track> track, ObjectPtr<Arti
}
EnumSet<TrackArtistLinkType>
TrackArtistLink::getUsedTypes(Session& session)
TrackArtistLink::findUsedTypes(Session& session)
{
session.checkSharedLocked();
src/libs/services/database/impl/TrackBookmark.cpp
+20 -21
View File
@@ -22,7 +22,8 @@
#include "services/database/Session.hpp"
#include "services/database/Track.hpp"
#include "services/database/User.hpp"
#include "Traits.hpp"
#include "IdTypeTraits.hpp"
#include "Utils.hpp"
namespace Database {
@@ -32,6 +33,15 @@ _track {getDboPtr(track)}
{
}
std::size_t
TrackBookmark::getCount(Session& session)
{
session.checkSharedLocked();
return session.getDboSession().query<int>("SELECT COUNT(*) FROM track_bookmark");
}
TrackBookmark::pointer
TrackBookmark::create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track)
{
@@ -43,40 +53,30 @@ TrackBookmark::create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> t
return res;
}
std::vector<TrackBookmark::pointer>
TrackBookmark::getAll(Session& session)
RangeResults<TrackBookmarkId>
TrackBookmark::find(Session& session, UserId userId, Range range)
{
session.checkSharedLocked();
auto res {session.getDboSession().find<TrackBookmark>().resultList()};
return std::vector<TrackBookmark::pointer>(std::cbegin(res), std::cend(res));
}
auto query {session.getDboSession().query<TrackBookmarkId>("SELECT id from track_bookmark")
.where("user_id = ?").bind(userId)};
std::vector<TrackBookmark::pointer>
TrackBookmark::getByUser(Session& session, User::pointer user)
{
session.checkSharedLocked();
auto res {session.getDboSession().find<TrackBookmark>()
.where("user_id = ?").bind(user->getId())
.resultList()};
return std::vector<TrackBookmark::pointer>(std::cbegin(res), std::cend(res));
return execQuery(query, range);
}
TrackBookmark::pointer
TrackBookmark::getByUser(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track)
TrackBookmark::find(Session& session, UserId userId, TrackId trackId)
{
session.checkSharedLocked();
return session.getDboSession().find<TrackBookmark>()
.where("user_id = ?").bind(user->getId())
.where("track_id = ?").bind(track->getId())
.where("user_id = ?").bind(userId)
.where("track_id = ?").bind(trackId)
.resultValue();
}
TrackBookmark::pointer
TrackBookmark::getById(Session& session, TrackBookmarkId id)
TrackBookmark::find(Session& session, TrackBookmarkId id)
{
session.checkSharedLocked();
@@ -85,6 +85,5 @@ TrackBookmark::getById(Session& session, TrackBookmarkId id)
.resultValue();
}
} // namespace Database
src/libs/services/database/impl/TrackFeatures.cpp
+50 -5
View File
@@ -25,6 +25,8 @@
#include "services/database/Session.hpp"
#include "services/database/Track.hpp"
#include "utils/Logger.hpp"
#include "IdTypeTraits.hpp"
#include "Utils.hpp"
namespace Database {
@@ -34,11 +36,53 @@ _track {getDboPtr(track)}
{
}
std::size_t
TrackFeatures::getCount(Session& session)
{
session.checkSharedLocked();
return session.getDboSession().query<int>("SELECT COUNT(*) FROM track_features");
}
TrackFeatures::pointer
TrackFeatures::find(Session& session, TrackFeaturesId id)
{
session.checkSharedLocked();
return session.getDboSession().find<TrackFeatures>()
.where("id = ?").bind(id)
.resultValue();
}
TrackFeatures::pointer
TrackFeatures::find(Session& session, TrackId trackId)
{
session.checkSharedLocked();
return session.getDboSession().find<TrackFeatures>()
.where("track_id = ?").bind(trackId)
.resultValue();
}
RangeResults<TrackFeaturesId>
TrackFeatures::find(Session& session, Range range)
{
session.checkSharedLocked();
auto query {session.getDboSession().query<TrackFeaturesId>("SELECT id from track_features")};
return execQuery(query, range);
}
TrackFeatures::pointer
TrackFeatures::create(Session& session, ObjectPtr<Track> track, const std::string& jsonEncodedFeatures)
{
session.checkUniqueLocked();
return session.getDboSession().add(std::make_unique<TrackFeatures>(track, jsonEncodedFeatures));
TrackFeatures::pointer res {session.getDboSession().add(std::make_unique<TrackFeatures>(track, jsonEncodedFeatures))};
session.getDboSession().flush();
return res;
}
FeatureValues
@@ -51,6 +95,8 @@ TrackFeatures::getFeatureValues(const FeatureName& featureNode) const
FeatureValuesMap
TrackFeatures::getFeatureValuesMap(const std::unordered_set<FeatureName>& featureNames) const
{
FeatureValuesMap res;
try
{
std::istringstream iss {_data};
@@ -58,7 +104,6 @@ TrackFeatures::getFeatureValuesMap(const std::unordered_set<FeatureName>& featur
boost::property_tree::read_json(iss, root);
FeatureValuesMap res;
for (const FeatureName& featureName : featureNames)
{
FeatureValues& featureValues {res[featureName]};
@@ -75,14 +120,14 @@ TrackFeatures::getFeatureValuesMap(const std::unordered_set<FeatureName>& featur
if (!hasChildren)
featureValues.push_back(node.get_value<double>());
}
return res;
}
catch (boost::property_tree::ptree_error& error)
{
LMS_LOG(DB, ERROR) << "Track " << _track.id() << ": ptree exception: " << error.what();
return {};
res.clear();
}
return res;
}
} // namespace Database
src/libs/services/database/impl/TrackList.cpp
+139 -51
View File
@@ -30,7 +30,8 @@
#include "services/database/Track.hpp"
#include "SqlQuery.hpp"
#include "StringViewTraits.hpp"
#include "Traits.hpp"
#include "IdTypeTraits.hpp"
#include "Utils.hpp"
namespace Database {
@@ -55,56 +56,54 @@ TrackList::create(Session& session, std::string_view name, Type type, bool isPub
return res;
}
TrackList::pointer
TrackList::get(Session& session, std::string_view name, Type type, ObjectPtr<User> user)
std::size_t
TrackList::getCount(Session& session)
{
session.checkSharedLocked();
assert(user);
return session.getDboSession().query<int>("SELECT COUNT(*) FROM tracklist");
}
TrackList::pointer
TrackList::find(Session& session, std::string_view name, Type type, UserId userId)
{
session.checkSharedLocked();
assert(userId.isValid());
return session.getDboSession().find<TrackList>()
.where("name = ?").bind(name)
.where("type = ?").bind(type)
.where("user_id = ?").bind(user->getId()).resultValue();
.where("user_id = ?").bind(userId).resultValue();
}
std::vector<TrackList::pointer>
TrackList::getAll(Session& session)
RangeResults<TrackListId>
TrackList::find(Session& session, UserId userId, Range range)
{
session.checkSharedLocked();
auto res = session.getDboSession().find<TrackList>().resultList();
return std::vector<TrackList::pointer>(res.begin(), res.end());
auto query {session.getDboSession().query<TrackListId>("SELECT id FROM tracklist")
.where("user_id = ?").bind(userId)
.orderBy("name COLLATE NOCASE")};
return execQuery(query, range);
}
std::vector<TrackList::pointer>
TrackList::getAll(Session& session, ObjectPtr<User> user)
RangeResults<TrackListId>
TrackList::find(Session& session, UserId userId, Type type, Range range)
{
session.checkSharedLocked();
auto res {session.getDboSession().find<TrackList>()
.where("user_id = ?").bind(user->getId())
.orderBy("name COLLATE NOCASE")
.resultList()};
return std::vector<TrackList::pointer>(res.begin(), res.end());
}
std::vector<TrackList::pointer>
TrackList::getAll(Session& session, ObjectPtr<User> user, Type type)
{
session.checkSharedLocked();
auto res {session.getDboSession().find<TrackList>()
.where("user_id = ?").bind(user->getId())
auto query {session.getDboSession().query<TrackListId>("SELECT id FROM tracklist")
.where("user_id = ?").bind(userId)
.where("type = ?").bind(type)
.orderBy("name COLLATE NOCASE")
.resultList()};
.orderBy("name COLLATE NOCASE")};
return std::vector<TrackList::pointer>(res.begin(), res.end());
return execQuery(query, range);
}
TrackList::pointer
TrackList::getById(Session& session, TrackListId id)
TrackList::find(Session& session, TrackListId id)
{
session.checkSharedLocked();
@@ -159,7 +158,7 @@ TrackList::getEntryByTrackAndDateTime(ObjectPtr<Track> track, const Wt::WDateTim
return session()->find<TrackListEntry>()
.where("tracklist_id = ?").bind(getId())
.where("track_id = ?").bind(track->getId())
.where("date_time = ?").bind(Wt::WDateTime::fromTime_t(dateTime.toTime_t()))
.where("date_time = ?").bind(normalizeDateTime(dateTime))
.resultValue();
}
@@ -270,19 +269,109 @@ createTracksQuery(Wt::Dbo::Session& session, TrackListId tracklistId, const std:
}
std::vector<Artist::pointer>
TrackList::getArtistsReverse(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const
TrackList::getArtists(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, ArtistSortMethod sortMethod, std::optional<Range> range, bool& moreResults) const
{
assert(session());
auto query {createArtistsQuery(*session(), "SELECT a from artist a", getId(), clusterIds, linkType)
.groupBy("a.id").having("p_e.date_time = MAX(p_e.date_time)")
.limit(range ? static_cast<int>(range->size) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1)};
switch (sortMethod)
{
case ArtistSortMethod::None:
break;
case ArtistSortMethod::ByName:
query.orderBy("a.name COLLATE NOCASE");
break;
case ArtistSortMethod::BySortName:
query.orderBy("a.sort_name COLLATE NOCASE");
break;
case ArtistSortMethod::Random:
query.orderBy("RANDOM()");
break;
case ArtistSortMethod::LastWritten:
case ArtistSortMethod::StarredDateDesc:
assert(false); // Not implemented!
break;
}
Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection {query.resultList()};
auto res {std::vector<Artist::pointer>(collection.begin(), collection.end())};
if (range && res.size() == static_cast<std::size_t>(range->size) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return res;
}
std::vector<ObjectPtr<Release>>
TrackList::getReleases(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
{
assert(session());
auto collection {createReleasesQuery(*session(), "SELECT r from release r", getId(), clusterIds)
.groupBy("r.id").having("p_e.date_time = MAX(p_e.date_time)")
.limit(range ? static_cast<int>(range->size) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1)
.resultList()};
std::vector<Release::pointer> res(collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->size) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return res;
}
std::vector<ObjectPtr<Track>>
TrackList::getTracks(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
{
assert(session());
auto collection {createTracksQuery(*session(), getId(), clusterIds)
.groupBy("t.id").having("p_e.date_time = MAX(p_e.date_time)")
.limit(range ? static_cast<int>(range->size) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1)
.resultList()};
std::vector<Track::pointer> res(collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->size) + 1)
{
moreResults = true;
res.pop_back();
}
else
moreResults = false;
return res;
}
std::vector<Artist::pointer>
TrackList::getArtistsOrderedByRecentFirst(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const
{
assert(session());
auto collection {createArtistsQuery(*session(), "SELECT a from artist a", getId(), clusterIds, linkType)
.groupBy("a.id").having("p_e.date_time = MAX(p_e.date_time)")
.orderBy("p_e.date_time DESC")
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.orderBy("p_e.date_time DESC, p_e.id DESC")
.limit(range ? static_cast<int>(range->size) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1)
.resultList()};
auto res {std::vector<Artist::pointer>(collection.begin(), collection.end())};
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
if (range && res.size() == static_cast<std::size_t>(range->size) + 1)
{
moreResults = true;
res.pop_back();
@@ -294,19 +383,19 @@ TrackList::getArtistsReverse(const std::vector<ClusterId>& clusterIds, std::opti
}
std::vector<Release::pointer>
TrackList::getReleasesReverse(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
TrackList::getReleasesOrderedByRecentFirst(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
{
assert(session());
auto collection {createReleasesQuery(*session(), "SELECT r from release r", getId(), clusterIds)
.groupBy("r.id").having("p_e.date_time = MAX(p_e.date_time)")
.orderBy("p_e.date_time DESC")
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.orderBy("p_e.date_time DESC, p_e.id DESC")
.limit(range ? static_cast<int>(range->size) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1)
.resultList()};
std::vector<Release::pointer> res(collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
if (range && res.size() == static_cast<std::size_t>(range->size) + 1)
{
moreResults = true;
res.pop_back();
@@ -318,19 +407,19 @@ TrackList::getReleasesReverse(const std::vector<ClusterId>& clusterIds, std::opt
}
std::vector<Track::pointer>
TrackList::getTracksReverse(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
TrackList::getTracksOrderedByRecentFirst(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
{
assert(session());
auto collection {createTracksQuery(*session(), getId(), clusterIds)
.groupBy("t.id").having("p_e.date_time = MAX(p_e.date_time)")
.orderBy("p_e.date_time DESC")
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.orderBy("p_e.date_time DESC, p_e.id DESC")
.limit(range ? static_cast<int>(range->size) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1)
.resultList()};
std::vector<Track::pointer> res(collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
if (range && res.size() == static_cast<std::size_t>(range->size) + 1)
{
moreResults = true;
res.pop_back();
@@ -424,13 +513,13 @@ TrackList::getTopArtists(const std::vector<ClusterId>& clusterIds, std::optional
auto collection {query
.orderBy("COUNT(a.id) DESC")
.groupBy("a.id")
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.limit(range ? static_cast<int>(range->size) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1)
.resultList()};
std::vector<Artist::pointer> res(collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
if (range && res.size() == static_cast<std::size_t>(range->size) + 1)
{
moreResults = true;
res.pop_back();
@@ -450,12 +539,12 @@ TrackList::getTopReleases(const std::vector<ClusterId>& clusterIds, std::optiona
auto collection {query
.orderBy("COUNT(r.id) DESC")
.groupBy("r.id")
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.limit(range ? static_cast<int>(range->size) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1)
.resultList()};
std::vector<Release::pointer> res(collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
if (range && res.size() == static_cast<std::size_t>(range->size) + 1)
{
moreResults = true;
res.pop_back();
@@ -475,12 +564,12 @@ TrackList::getTopTracks(const std::vector<ClusterId>& clusterIds, std::optional<
auto collection {query
.orderBy("COUNT(t.id) DESC")
.groupBy("t.id")
.limit(range ? static_cast<int>(range->limit) + 1 : -1)
.limit(range ? static_cast<int>(range->size) + 1 : -1)
.offset(range ? static_cast<int>(range->offset) : -1)
.resultList()};
std::vector<Track::pointer> res(collection.begin(), collection.end());
if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
if (range && res.size() == static_cast<std::size_t>(range->size) + 1)
{
moreResults = true;
res.pop_back();
@@ -492,11 +581,10 @@ TrackList::getTopTracks(const std::vector<ClusterId>& clusterIds, std::optional<
}
TrackListEntry::TrackListEntry(ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist, const Wt::WDateTime& dateTime)
: _dateTime {Wt::WDateTime::fromTime_t(dateTime.toTime_t())} // force second resolution
: _dateTime {normalizeDateTime(dateTime)}
, _track {getDboPtr(track)}
, _tracklist {getDboPtr(tracklist)}
{
assert(_dateTime.isValid());
}
TrackListEntry::pointer
src/libs/services/database/impl/Types.cpp
+52
View File
@@ -0,0 +1,52 @@
/*
* Copyright (C) 2015 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "services/database/Types.hpp"
#include <set>
namespace Database
{
static const std::set<Bitrate> allowedAudioBitrates
{
64000,
96000,
128000,
192000,
320000,
};
void visitAllowedAudioBitrates(std::function<void(Bitrate)> func)
{
for (Bitrate bitrate : allowedAudioBitrates)
func(bitrate);
}
bool isAudioBitrateAllowed(Bitrate bitrate)
{
return allowedAudioBitrates.find(bitrate) != std::cend(allowedAudioBitrates);
}
DateRange
DateRange::fromYearRange(int from, int to)
{
return DateRange {{from, 1, 1}, {to, 12, 31}};
}
}
src/libs/services/database/impl/User.cpp
+23 -144
View File
@@ -23,85 +23,18 @@
#include "services/database/Release.hpp"
#include "services/database/Session.hpp"
#include "services/database/Track.hpp"
#include "services/database/TrackList.hpp"
#include "utils/Logger.hpp"
#include "IdTypeTraits.hpp"
#include "StringViewTraits.hpp"
#include "Traits.hpp"
#include "Utils.hpp"
namespace Database {
AuthToken::AuthToken(const std::string& value, const Wt::WDateTime& expiry, ObjectPtr<User> user)
: _value {value}
, _expiry {expiry}
, _user {getDboPtr(user)}
{
}
AuthToken::pointer
AuthToken::create(Session& session, const std::string& value, const Wt::WDateTime& expiry, ObjectPtr<User> user)
{
session.checkUniqueLocked();
AuthToken::pointer res {session.getDboSession().add(std::make_unique<AuthToken>(value, expiry, user))};
session.getDboSession().flush();
return res;
}
void
AuthToken::removeExpiredTokens(Session& session, const Wt::WDateTime& now)
{
session.checkUniqueLocked();
session.getDboSession().execute
("DELETE FROM auth_token WHERE expiry < ?").bind(now);
}
AuthToken::pointer
AuthToken::getByValue(Session& session, const std::string& value)
{
session.checkSharedLocked();
return session.getDboSession().find<AuthToken>()
.where("value = ?").bind(value)
.resultValue();
}
static const std::string queuedListName {"__queued_tracks__"};
User::User(std::string_view loginName)
: _loginName {loginName}
{
}
std::vector<User::pointer>
User::getAll(Session& session)
{
session.checkSharedLocked();
auto res {session.getDboSession().find<User>().resultList()};
return std::vector<pointer>(res.begin(), res.end());
}
std::vector<UserId>
User::getAllIds(Session& session)
{
session.checkSharedLocked();
auto res {session.getDboSession().query<UserId>("SELECT id FROM user").resultList()};
return std::vector<UserId>(res.begin(), res.end());
}
User::pointer
User::getDemo(Session& session)
{
session.checkSharedLocked();
return session.getDboSession().find<User>().where("type = ?").bind(UserType::DEMO).resultValue();
}
std::size_t
User::getCount(Session& session)
{
@@ -110,28 +43,43 @@ User::getCount(Session& session)
return session.getDboSession().query<int>("SELECT COUNT(*) FROM user");
}
RangeResults<UserId>
User::find(Session& session, Range range)
{
session.checkSharedLocked();
auto query {session.getDboSession().query<UserId>("SELECT id FROM user")};
return execQuery(query, range);
}
User::pointer
User::findDemoUser(Session& session)
{
session.checkSharedLocked();
return session.getDboSession().find<User>().where("type = ?").bind(UserType::DEMO).resultValue();
}
User::pointer
User::create(Session& session, std::string_view loginName)
{
session.checkUniqueLocked();
User::pointer user {session.getDboSession().add(std::make_unique<User>(loginName))};
TrackList::create(session, queuedListName, TrackList::Type::Internal, false, user);
session.getDboSession().flush();
return user;
}
User::pointer
User::getById(Session& session, UserId id)
User::find(Session& session, UserId id)
{
return session.getDboSession().find<User>().where("id = ?").bind(id).resultValue();
}
User::pointer
User::getByLoginName(Session& session, std::string_view name)
User::find(Session& session, std::string_view name)
{
return session.getDboSession().find<User>()
.where("login_name = ?").bind(name)
@@ -141,7 +89,7 @@ User::getByLoginName(Session& session, std::string_view name)
void
User::setSubsonicTranscodeBitrate(Bitrate bitrate)
{
assert(audioTranscodeAllowedBitrates.find(bitrate) != audioTranscodeAllowedBitrates.cend());
assert(isAudioBitrateAllowed(bitrate));
_subsonicTranscodeBitrate = bitrate;
}
@@ -151,75 +99,6 @@ User::clearAuthTokens()
_authTokens.clear();
}
TrackList::pointer
User::getQueuedTrackList(Session& session) const
{
assert(self());
session.checkSharedLocked();
return TrackList::get(session, queuedListName, TrackList::Type::Internal, self());
}
void
User::star(ObjectPtr<Artist> artist)
{
if (_starredArtists.count(getDboPtr(artist)) == 0)
_starredArtists.insert(getDboPtr(artist));
}
void
User::unstar(ObjectPtr<Artist> artist)
{
if (_starredArtists.count(getDboPtr(artist)) != 0)
_starredArtists.erase(getDboPtr(artist));
}
bool
User::isStarred(ObjectPtr<Artist> artist) const
{
return _starredArtists.count(getDboPtr(artist)) != 0;
}
void
User::star(ObjectPtr<Release> release)
{
if (_starredReleases.count(getDboPtr(release)) == 0)
_starredReleases.insert(getDboPtr(release));
}
void
User::unstar(ObjectPtr<Release> release)
{
if (_starredReleases.count(getDboPtr(release)) != 0)
_starredReleases.erase(getDboPtr(release));
}
bool
User::isStarred(ObjectPtr<Release> release) const
{
return _starredReleases.count(getDboPtr(release)) != 0;
}
void
User::star(ObjectPtr<Track> track)
{
if (_starredTracks.count(getDboPtr(track)) == 0)
_starredTracks.insert(getDboPtr(track));
}
void
User::unstar(ObjectPtr<Track> track)
{
if (_starredTracks.count(getDboPtr(track)) != 0)
_starredTracks.erase(getDboPtr(track));
}
bool
User::isStarred(ObjectPtr<Track> track) const
{
return _starredTracks.count(getDboPtr(track)) != 0;
}
} // namespace Database
src/libs/services/database/impl/Utils.cpp
+7
View File
@@ -29,5 +29,12 @@ namespace Database
return StringUtils::escapeString(keyword, "%_", escapeChar);
}
Wt::WDateTime
normalizeDateTime(const Wt::WDateTime& dateTime)
{
// force second resolution
return Wt::WDateTime::fromTime_t(dateTime.toTime_t());
}
} // namespace Database
src/libs/services/database/impl/Utils.hpp
+55 -2
View File
@@ -21,13 +21,66 @@
#include <string>
#include <string_view>
#include <vector>
#include <Wt/Dbo/Dbo.h>
#include <Wt/WDateTime.h>
#include "services/database/Types.hpp"
namespace Database
{
#define ESCAPE_CHAR_STR "\\"
static constexpr char escapeChar {'\\'};
static inline constexpr char escapeChar {'\\'};
std::string escapeLikeKeyword(std::string_view keywords);
template <typename T>
RangeResults<T>
execQuery(Wt::Dbo::Query<T>& query, Range range)
{
RangeResults<T> res;
auto collection {query.limit(range.size ? static_cast<int>(range.size) + 1 : -1)
.offset(range.offset ? static_cast<int>(range.offset) : -1)
.resultList()};
res.results.assign(collection.begin(), collection.end());
if (range.size && res.results.size() == static_cast<std::size_t>(range.size) + 1)
{
res.moreResults = true;
res.results.pop_back();
}
else
res.moreResults = false;
res.range.offset = range.offset;
res.range.size = res.results.size();
return res;
}
template <typename T>
RangeResults<typename T::pointer>
execQuery(Wt::Dbo::Query<Wt::Dbo::ptr<T>>& query, Range range)
{
RangeResults<typename T::pointer> res;
auto collection {query.limit(range.size ? static_cast<int>(range.size) + 1 : -1)
.offset(range.offset ? static_cast<int>(range.offset) : -1)
.resultList()};
res.results.assign(collection.begin(), collection.end());
if (range.size && res.results.size() == static_cast<std::size_t>(range.size) + 1)
{
res.moreResults = true;
res.results.pop_back();
}
else
res.moreResults = false;
res.range.offset = range.offset;
res.range.size = res.results.size();
return res;
}
Wt::WDateTime normalizeDateTime(const Wt::WDateTime& dateTime);
} // namespace Database
src/libs/services/database/include/services/database/Artist.hpp
+35 -44
View File
@@ -27,7 +27,11 @@
#include <Wt/WDateTime.h>
#include <Wt/Dbo/Dbo.h>
#include "services/database/ArtistId.hpp"
#include "services/database/ClusterId.hpp"
#include "services/database/Object.hpp"
#include "services/database/Types.hpp"
#include "services/database/UserId.hpp"
#include "utils/EnumSet.hpp"
#include "utils/UUID.hpp"
@@ -38,6 +42,7 @@ class Cluster;
class ClusterType;
class Release;
class Session;
class StarredArtist;
class Track;
class TrackArtistLink;
class User;
@@ -45,67 +50,53 @@ class User;
class Artist : public Object<Artist, ArtistId>
{
public:
enum class SortMethod
struct FindParameters
{
None,
ByName,
BySortName,
std::vector<ClusterId> clusters; // if non empty, at least one artist that belongs to these clusters
std::vector<std::string_view> keywords; // if non empty, name must match all of these keywords (on either name field OR sort name field)
std::optional<TrackArtistLinkType> linkType; // if set, only artists that have produced at least one track with this link type
ArtistSortMethod sortMethod {ArtistSortMethod::None};
Range range;
Wt::WDateTime writtenAfter;
UserId starringUser; // only artists starred by this user
std::optional<Scrobbler> scrobbler; // and for this scrobbler
FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; }
FindParameters& setKeywords(const std::vector<std::string_view>& _keywords) { keywords = _keywords; return *this; }
FindParameters& setLinkType(std::optional<TrackArtistLinkType> _linkType) { linkType = _linkType; return *this; }
FindParameters& setSortMethod(ArtistSortMethod _sortMethod) {sortMethod = _sortMethod; return *this; }
FindParameters& setRange(Range _range) {range = _range; return *this; }
FindParameters& setWrittenAfter(const Wt::WDateTime& _after) { writtenAfter = _after; return *this; }
FindParameters& setStarringUser(UserId _user, Scrobbler _scrobbler) { starringUser = _user; scrobbler = _scrobbler; return *this; }
};
Artist() = default;
Artist(const std::string& name, const std::optional<UUID>& MBID = {});
// Accessors
static pointer getByMBID(Session& session, const UUID& MBID);
static pointer getById(Session& session, ArtistId id);
static bool exists(Session& session, ArtistId id);
static std::vector<pointer> getByName(Session& session, const std::string& name); // exact match on name field
static std::vector<pointer> getByClusters(Session& session,
const std::vector<ClusterId>& clusters, // at least one track that belongs to these clusters
SortMethod sortMethod
);
static std::vector<pointer> getByFilter(Session& session,
const std::vector<ClusterId>& clusters, // if non empty, at least one artist that belongs to these clusters
const std::vector<std::string_view>& keywords, // if non empty, name must match all of these keywords (name + sort name fields)
std::optional<TrackArtistLinkType> linkType, // if set, only artists that have produced at least one track with this link type
SortMethod sortMethod,
std::optional<Range> range,
bool& moreExpected);
static std::size_t getCount(Session& session);
static pointer find(Session& session, const UUID& MBID);
static pointer find(Session& session, ArtistId id);
static std::vector<pointer> find(Session& session, const std::string& name); // exact match on name field
static RangeResults<ArtistId> find(Session& session, const FindParameters& parameters);
static RangeResults<ArtistId> findAllOrphans(Session& session, Range range); // No track related
static bool exists(Session& session, ArtistId id);
static std::vector<pointer> getAll(Session& session);
static std::vector<pointer> getAll(Session& session, SortMethod sortMethod);
static std::vector<pointer> getAll(Session& session, SortMethod sortMethod, std::optional<Range> range, bool& moreResults);
static std::vector<ArtistId> getAllIds(Session& session);
static std::vector<ArtistId> getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<TrackArtistLinkType> linkType, std::optional<std::size_t> size = {});
static std::vector<pointer> getAllOrphans(Session& session); // No track related
static std::vector<pointer> getLastWritten(Session& session,
std::optional<Wt::WDateTime> after,
const std::vector<ClusterId>& clusters,
std::optional<TrackArtistLinkType> linkType, // if set, only artists that have produced at least one track with this link type
std::optional<Range>,
bool& moreResults);
static std::vector<ArtistId> getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit = {});
static std::vector<pointer> getStarred(Session& session,
ObjectPtr<User> user,
const std::vector<ClusterId>& clusters,
std::optional<TrackArtistLinkType> linkType, // if set, only artists that have produced at least one track with this link type
SortMethod sortMethod,
std::optional<Range>, bool& moreResults);
// Accessors
const std::string& getName() const { return _name; }
const std::string& getSortName() const { return _sortName; }
std::optional<UUID> getMBID() const { return UUID::fromString(_MBID); }
std::vector<ObjectPtr<Release>> getReleases(const std::vector<ClusterId>& clusterIds = {}) const; // if non empty, get the releases that match all these clusters
std::vector<ObjectPtr<Release>> getReleases(const std::vector<ClusterId>& clusterIds = {}) const; // if non empty, get the releases that match all these clusters
std::size_t getReleaseCount() const;
std::vector<ObjectPtr<Track>> getTracks(std::optional<TrackArtistLinkType> linkType = {}) const;
bool hasNonReleaseTracks(std::optional<TrackArtistLinkType> linkType = std::nullopt) const;
std::vector<ObjectPtr<Track>> getNonReleaseTracks(std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
RangeResults<ObjectPtr<Track>> getNonReleaseTracks(std::optional<TrackArtistLinkType> linkType, Range range) const;
std::vector<ObjectPtr<Track>> getRandomTracks(std::optional<std::size_t> count) const;
// No artistLinkTypes means get them all
std::vector<pointer> getSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes = {}, std::optional<Range> range = std::nullopt) const;
RangeResults<ArtistId> findSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes = {}, Range range = {}) const;
// Get the cluster of the tracks made by this artist
// Each clusters are grouped by cluster type, sorted by the number of occurence
@@ -127,7 +118,7 @@ class Artist : public Object<Artist, ArtistId>
Wt::Dbo::field(a, _MBID, "mbid");
Wt::Dbo::hasMany(a, _trackArtistLinks, Wt::Dbo::ManyToOne, "artist");
Wt::Dbo::hasMany(a, _starringUsers, Wt::Dbo::ManyToMany, "user_release_starred", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _starredArtists, Wt::Dbo::ManyToMany, "user_starred_artists", "", Wt::Dbo::OnDeleteCascade);
}
private:
@@ -138,8 +129,8 @@ class Artist : public Object<Artist, ArtistId>
std::string _sortName;
std::string _MBID; // Musicbrainz Identifier
Wt::Dbo::collection<Wt::Dbo::ptr<TrackArtistLink>> _trackArtistLinks; // Tracks involving this artist
Wt::Dbo::collection<Wt::Dbo::ptr<User>> _starringUsers; // Users that starred this artist
Wt::Dbo::collection<Wt::Dbo::ptr<TrackArtistLink>> _trackArtistLinks; // Tracks involving this artist
Wt::Dbo::collection<Wt::Dbo::ptr<StarredArtist>> _starredArtists; // starred entries for this artist
};
} // namespace Database
src/libs/services/database/include/services/database/ArtistId.hpp
+25
View File
@@ -0,0 +1,25 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "services/database/IdType.hpp"
LMS_DECLARE_IDTYPE(ArtistId)
src/libs/services/database/include/services/database/AuthToken.hpp
+66
View File
@@ -0,0 +1,66 @@
/*
* Copyright (C) 2013 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <string_view>
#include <Wt/Dbo/Dbo.h>
#include <Wt/WDateTime.h>
#include "services/database/AuthTokenId.hpp"
#include "services/database/Object.hpp"
namespace Database
{
class Session;
class User;
class AuthToken : public Object<AuthToken, AuthTokenId>
{
public:
AuthToken() = default;
AuthToken(std::string_view value, const Wt::WDateTime& expiry, ObjectPtr<User> user);
// Utility
static pointer create(Session& session, std::string_view value, const Wt::WDateTime&expiry, ObjectPtr<User> user);
static void removeExpiredTokens(Session& session, const Wt::WDateTime& now);
static pointer find(Session& session, std::string_view value);
// Accessors
const Wt::WDateTime& getExpiry() const { return _expiry; }
ObjectPtr<User> getUser() const { return _user; }
const std::string& getValue() const { return _value; }
template<class Action>
void persist(Action& a)
{
Wt::Dbo::field(a, _value, "value");
Wt::Dbo::field(a, _expiry, "expiry");
Wt::Dbo::belongsTo(a, _user, "user", Wt::Dbo::OnDeleteCascade);
}
private:
std::string _value;
Wt::WDateTime _expiry;
Wt::Dbo::ptr<User> _user;
};
} // namespace Databas'
src/libs/services/database/include/services/database/AuthTokenId.hpp
+24
View File
@@ -0,0 +1,24 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "services/database/IdType.hpp"
LMS_DECLARE_IDTYPE(AuthTokenId)
src/libs/services/database/include/services/database/Cluster.hpp
+21 -17
View File
@@ -26,6 +26,9 @@
#include <Wt/Dbo/Dbo.h>
#include <Wt/WDateTime.h>
#include "services/database/Object.hpp"
#include "services/database/ClusterId.hpp"
#include "services/database/TrackId.hpp"
#include "services/database/Types.hpp"
namespace Database {
@@ -42,20 +45,20 @@ class Cluster : public Object<Cluster, ClusterId>
Cluster(ObjectPtr<ClusterType> type, std::string_view name);
// Find utility
static std::vector<pointer> getAll(Session& session);
static std::vector<pointer> getAllOrphans(Session& session);
static pointer getById(Session& session, ClusterId id);
static std::size_t getCount(Session& session);
static RangeResults<ClusterId> find(Session& session, Range range);
static pointer find(Session& session, ClusterId id);
static RangeResults<ClusterId> findOrphans(Session& session, Range range);
// Create utility
static pointer create(Session& session, ObjectPtr<ClusterType> type, std::string_view name);
// Accessors
const std::string& getName() const { return _name; }
ObjectPtr<ClusterType> getType() const { return _clusterType; }
std::size_t getTracksCount() const { return _tracks.size(); }
std::vector<ObjectPtr<Track>> getTracks(std::optional<std::size_t> offset = {}, std::optional<std::size_t> limit = {}) const;
std::vector<TrackId> getTrackIds() const;
std::size_t getReleasesCount() const;
const std::string& getName() const { return _name; }
ObjectPtr<ClusterType> getType() const { return _clusterType; }
std::size_t getTracksCount() const { return _tracks.size(); }
RangeResults<TrackId> getTracks(Range range) const;
std::size_t getReleasesCount() const;
void addTrack(ObjectPtr<Track> track);
@@ -85,19 +88,20 @@ class ClusterType : public Object<ClusterType, ClusterTypeId>
ClusterType(std::string_view name);
// Getters
static std::vector<pointer> getAllOrphans(Session& session);
static std::vector<pointer> getAllUsed(Session& session);
static pointer getByName(Session& session, const std::string& name);
static pointer getById(Session& session, ClusterTypeId id);
static std::vector<pointer> getAll(Session& session);
static std::size_t getCount(Session& session);
static RangeResults<ClusterTypeId> find(Session& session, Range range);
static pointer find(Session& session, const std::string& name);
static pointer find(Session& session, ClusterTypeId id);
static RangeResults<ClusterTypeId> findOrphans(Session& session, Range range);
static RangeResults<ClusterTypeId> findUsed(Session& session, Range range);
static pointer create(Session& session, const std::string& name);
static void remove(Session& session, const std::string& name);
// Accessors
const std::string& getName(void) const { return _name; }
std::vector<Cluster::pointer> getClusters() const;
Cluster::pointer getCluster(const std::string& name) const;
const std::string& getName() const { return _name; }
std::vector<Cluster::pointer> getClusters() const;
Cluster::pointer getCluster(const std::string& name) const;
template<class Action>
void persist(Action& a)
src/libs/services/database/include/services/database/ClusterId.hpp
+26
View File
@@ -0,0 +1,26 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "services/database/IdType.hpp"
LMS_DECLARE_IDTYPE(ClusterId)
LMS_DECLARE_IDTYPE(ClusterTypeId)
src/libs/services/database/include/services/database/IdType.hpp
+72
View File
@@ -0,0 +1,72 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <cassert>
#include <functional>
#include <Wt/Dbo/ptr.h>
namespace Database
{
class IdType
{
public:
using ValueType = Wt::Dbo::dbo_default_traits::IdType;
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); }
ValueType getValue() const { return _id; }
bool operator==(IdType other) const { return other._id == _id; }
bool operator!=(IdType other) const { return !(*this == other); }
bool operator<(IdType other) const { return _id < other._id; }
bool operator>(IdType other) const { return _id > other._id; }
private:
Wt::Dbo::dbo_default_traits::IdType _id {Wt::Dbo::dbo_default_traits::invalidId()};
};
#define LMS_DECLARE_IDTYPE(name) \
namespace Database { \
class name : public IdType \
{ \
public: \
using IdType::IdType; \
};\
} \
namespace std \
{ \
template<> \
class hash<Database::name> \
{ \
public: \
size_t operator()(Database::name id) const \
{ \
return std::hash<Database::name::ValueType>()(id.getValue()); \
} \
}; \
} // ns std
} // namespace Database
src/libs/services/database/include/services/database/Listen.hpp
+111
View File
@@ -0,0 +1,111 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <Wt/Dbo/Dbo.h>
#include <Wt/WDateTime.h>
#include "services/database/ArtistId.hpp"
#include "services/database/ClusterId.hpp"
#include "services/database/IdType.hpp"
#include "services/database/Object.hpp"
#include "services/database/ReleaseId.hpp"
#include "services/database/TrackId.hpp"
#include "services/database/Types.hpp"
#include "services/database/UserId.hpp"
LMS_DECLARE_IDTYPE(ListenId)
namespace Database
{
class Session;
class Track;
class User;
class Listen : public Object<Listen, ListenId>
{
public:
Listen() = default;
Listen(ObjectPtr<User> user, ObjectPtr<Track> track, Scrobbler scrobbler, const Wt::WDateTime& dateTime);
// Accessors
static std::size_t getCount(Session& session);
static pointer find(Session& session, ListenId id);
static RangeResults<pointer> find(Session& session, UserId userId, Scrobbler scrobbler, Range = {});
static pointer find(Session& session, UserId userId, TrackId trackId, Scrobbler scrobbler, const Wt::WDateTime& dateTime);
// Create
static pointer create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track, Scrobbler scrobbler, const Wt::WDateTime& dateTime);
// Stats
static RangeResults<ArtistId> getTopArtists(Session& session,
UserId userId,
Scrobbler scrobbler,
const std::vector<ClusterId>& clusterIds,
std::optional<TrackArtistLinkType> linkType,
Range range = {});
static RangeResults<ReleaseId> getTopReleases(Session& session,
UserId userId,
Scrobbler scrobbler,
const std::vector<ClusterId>& clusterIds,
Range range = {});
static RangeResults<TrackId> getTopTracks(Session& session,
UserId userId,
Scrobbler scrobbler,
const std::vector<ClusterId>& clusterIds,
Range range = {});
static RangeResults<ArtistId> getRecentArtists(Session& session,
UserId userId,
Scrobbler scrobbler,
const std::vector<ClusterId>& clusterIds,
std::optional<TrackArtistLinkType> linkType,
Range range = {});
static RangeResults<ReleaseId> getRecentReleases(Session& session,
UserId userId,
Scrobbler scrobbler,
const std::vector<ClusterId>& clusterIds,
Range range = {});
static RangeResults<TrackId> getRecentTracks(Session& session,
UserId userId,
Scrobbler scrobbler,
const std::vector<ClusterId>& clusterIds,
Range range = {});
template<class Action>
void persist(Action& a)
{
Wt::Dbo::field(a, _dateTime, "date_time");
Wt::Dbo::field(a, _scrobbler, "scrobbler");
Wt::Dbo::belongsTo(a, _track, "track", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::belongsTo(a, _user, "user", Wt::Dbo::OnDeleteCascade);
}
private:
Wt::WDateTime _dateTime;
Scrobbler _scrobbler;
Wt::Dbo::ptr<User> _user;
Wt::Dbo::ptr<Track> _track;
};
} // namespace Database
src/libs/services/database/include/services/database/Object.hpp
+67
View File
@@ -0,0 +1,67 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <Wt/Dbo/ptr.h>
#include "services/database/IdType.hpp"
namespace Database
{
template <typename T>
class ObjectPtr
{
public:
ObjectPtr() = default;
ObjectPtr(Wt::Dbo::ptr<T> obj) : _obj {obj} {}
const T* operator->() const { return _obj.get(); }
operator bool() const { return _obj.get(); }
bool operator!() const { return !_obj.get(); }
auto modify() { return _obj.modify(); }
void remove() { _obj.remove(); }
private:
template <typename, typename> friend class Object;
Wt::Dbo::ptr<T> _obj;
};
template <typename T, typename ObjectIdType>
class Object : public Wt::Dbo::Dbo<T>
{
static_assert(std::is_base_of_v<Database::IdType, ObjectIdType>);
static_assert(!std::is_same_v<Database::IdType, ObjectIdType>);
public:
using pointer = ObjectPtr<T>;
using IdType = ObjectIdType;
IdType getId() const { return Wt::Dbo::Dbo<T>::self()->Wt::Dbo::template Dbo<T>::id(); }
// catch some misuses
typename Wt::Dbo::dbo_traits<T>::IdType id() const = delete;
protected:
// Can get raw dbo ptr only from Objects
template <typename SomeObject>
static
Wt::Dbo::ptr<SomeObject> getDboPtr(ObjectPtr<SomeObject> ptr) { return ptr._obj; }
};
}
src/libs/services/database/include/services/database/Release.hpp
+35 -27
View File
@@ -25,7 +25,11 @@
#include <Wt/WDateTime.h>
#include <Wt/Dbo/Dbo.h>
#include "services/database/ClusterId.hpp"
#include "services/database/Object.hpp"
#include "services/database/ReleaseId.hpp"
#include "services/database/Types.hpp"
#include "services/database/UserId.hpp"
#include "utils/UUID.hpp"
namespace Database
@@ -42,36 +46,42 @@ class User;
class Release : public Object<Release, ReleaseId>
{
public:
struct FindParameters
{
std::vector<ClusterId> clusters; // if non empty, releases that belong to these clusters
std::vector<std::string_view> keywords; // if non empty, name must match all of these keywords
ReleaseSortMethod sortMethod {ReleaseSortMethod::None};
Range range;
Wt::WDateTime writtenAfter;
std::optional<DateRange> dateRange;
UserId starringUser; // only releases starred by this user
std::optional<Scrobbler> scrobbler; // and for this scrobbler
FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; }
FindParameters& setKeywords(const std::vector<std::string_view>& _keywords) { keywords = _keywords; return *this; }
FindParameters& setSortMethod(ReleaseSortMethod _sortMethod) {sortMethod = _sortMethod; return *this; }
FindParameters& setRange(Range _range) {range = _range; return *this; }
FindParameters& setWrittenAfter(const Wt::WDateTime& _after) {writtenAfter = _after; return *this; }
FindParameters& setDateRange(const std::optional<DateRange>& _dateRange) {dateRange = _dateRange; return *this; }
FindParameters& setStarringUser(UserId _user, Scrobbler _scrobbler) { starringUser = _user; scrobbler = _scrobbler; return *this; }
};
Release() = default;
Release(const std::string& name, const std::optional<UUID>& MBID = {});
// Accessors
static std::size_t getCount(Session& session);
static pointer getByMBID(Session& session, const UUID& MBID);
static std::vector<pointer> getByName(Session& session, const std::string& name);
static pointer getById(Session& session, ReleaseId id);
static bool exists(Session& session, ReleaseId id);
static std::vector<pointer> getAllOrphans(Session& session); // no track related
static std::vector<pointer> getAll(Session& session, std::optional<Range> range = std::nullopt);
static std::vector<ReleaseId> getAllIds(Session& session);
static std::vector<pointer> getAllOrderedByArtist(Session& session, std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {});
static std::vector<pointer> getAllRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<std::size_t> size = {});
static std::vector<ReleaseId> getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<std::size_t> size = {});
static std::vector<pointer> getLastWritten(Session& session, std::optional<Wt::WDateTime> after, const std::vector<ClusterId>& clusters, std::optional<Range> range, bool& moreResults);
static std::vector<pointer> getByYear(Session& session, int yearFrom, int yearTo, std::optional<Range> range = std::nullopt);
static std::vector<pointer> getStarred(Session& session, ObjectPtr<User> user, const std::vector<ClusterId>& clusters, std::optional<Range> range, bool& moreResults);
static std::size_t getCount(Session& session);
static bool exists(Session& session, ReleaseId id);
static pointer find(Session& session, const UUID& MBID);
static std::vector<pointer> find(Session& session, const std::string& name);
static pointer find(Session& session, ReleaseId id);
static RangeResults<ReleaseId> find(Session& session, const FindParameters& parameters);
static RangeResults<ReleaseId> findOrphans(Session& session, Range range); // no track related
static RangeResults<ReleaseId> findOrderedByArtist(Session& session, Range range);
static std::vector<pointer> getByClusters(Session& session, const std::vector<ClusterId>& clusters);
static std::vector<pointer> getByFilter(Session& session,
const std::vector<ClusterId>& clusters, // if non empty, at least one release that belongs to these clusters
const std::vector<std::string_view>& keywords, // if non empty, name must match all of these keywords
std::optional<Range> range,
bool& moreExpected);
static std::vector<ReleaseId> getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit = {});
std::vector<ObjectPtr<Track>> getTracks(const std::vector<ClusterId>& clusters = {}) const;
std::size_t getTracksCount() const;
ObjectPtr<Track> getFirstTrack() const;
std::vector<ObjectPtr<Track>> getTracks(const std::vector<ClusterId>& clusters = {}) const;
std::size_t getTracksCount() const;
ObjectPtr<Track> getFirstTrack() const;
// Get the cluster of the tracks that belong to this release
// Each clusters are grouped by cluster type, sorted by the number of occurence (max to min)
@@ -110,7 +120,6 @@ class Release : public Object<Release, ReleaseId>
Wt::Dbo::field(a, _MBID, "mbid");
Wt::Dbo::hasMany(a, _tracks, Wt::Dbo::ManyToOne, "release");
Wt::Dbo::hasMany(a, _starringUsers, Wt::Dbo::ManyToMany, "user_release_starred", "", Wt::Dbo::OnDeleteCascade);
}
private:
@@ -120,7 +129,6 @@ class Release : public Object<Release, ReleaseId>
std::string _MBID;
Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _tracks; // Tracks in the release
Wt::Dbo::collection<Wt::Dbo::ptr<User>> _starringUsers; // Users that starred this release
};
} // namespace Database
src/libs/services/database/include/services/database/ReleaseId.hpp
+25
View File
@@ -0,0 +1,25 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "services/database/IdType.hpp"
LMS_DECLARE_IDTYPE(ReleaseId)
src/libs/services/database/include/services/database/ScanSettings.hpp
+4 -1
View File
@@ -25,7 +25,10 @@
#include <Wt/Dbo/Dbo.h>
#include <Wt/WTime.h>
#include "services/database/Types.hpp"
#include "services/database/IdType.hpp"
#include "services/database/Object.hpp"
LMS_DECLARE_IDTYPE(ScanSettingsId)
namespace Database {
src/libs/services/database/include/services/database/StarredArtist.hpp
+81
View File
@@ -0,0 +1,81 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <Wt/WDateTime.h>
#include <Wt/Dbo/Dbo.h>
#include "services/database/ArtistId.hpp"
#include "services/database/IdType.hpp"
#include "services/database/Object.hpp"
#include "services/database/Session.hpp"
#include "services/database/Types.hpp"
#include "services/database/UserId.hpp"
LMS_DECLARE_IDTYPE(StarredArtistId)
namespace Database
{
class Artist;
class Session;
class User;
class StarredArtist : public Object<StarredArtist, StarredArtistId>
{
public:
StarredArtist() = default;
StarredArtist(ObjectPtr<Artist> artist, ObjectPtr<User> user, Scrobbler scrobbler);
// Search utility
static std::size_t getCount(Session& session);
static pointer find(Session& session, StarredArtistId id);
static pointer find(Session& session, ArtistId artistId, UserId userId, Scrobbler scrobbler);
// Create utility
static pointer create(Session& session, ObjectPtr<Artist> artist, ObjectPtr<User> user, Scrobbler scrobbler);
// Accessors
ObjectPtr<Artist> getArtist() const { return _artist; }
ObjectPtr<User> getUser() const { return _user; }
Scrobbler getScrobbler() const { return _scrobbler; }
const Wt::WDateTime& getDateTime() const { return _dateTime; }
// Setters
void setDateTime(const Wt::WDateTime& dateTime);
template<class Action>
void persist(Action& a)
{
Wt::Dbo::field(a, _scrobbler, "scrobbler");
Wt::Dbo::field(a, _dateTime, "date_time");
Wt::Dbo::belongsTo(a, _artist, "artist", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::belongsTo(a, _user, "user", Wt::Dbo::OnDeleteCascade);
}
private:
Scrobbler _scrobbler; // for which scrobbler
Wt::WDateTime _dateTime; // when it was starred
Wt::Dbo::ptr<Artist> _artist;
Wt::Dbo::ptr<User> _user;
};
} // namespace Database
src/libs/services/database/include/services/database/StarredRelease.hpp
+81
View File
@@ -0,0 +1,81 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <Wt/WDateTime.h>
#include <Wt/Dbo/Dbo.h>
#include "services/database/ReleaseId.hpp"
#include "services/database/IdType.hpp"
#include "services/database/Object.hpp"
#include "services/database/Session.hpp"
#include "services/database/Types.hpp"
#include "services/database/UserId.hpp"
LMS_DECLARE_IDTYPE(StarredReleaseId)
namespace Database
{
class Release;
class Session;
class User;
class StarredRelease : public Object<StarredRelease, StarredReleaseId>
{
public:
StarredRelease() = default;
StarredRelease(ObjectPtr<Release> release, ObjectPtr<User> user, Scrobbler scrobbler);
// Search utility
static std::size_t getCount(Session& session);
static pointer find(Session& session, StarredReleaseId id);
static pointer find(Session& session, ReleaseId releaseId, UserId userId, Scrobbler scrobbler);
// Create utility
static pointer create(Session& session, ObjectPtr<Release> release, ObjectPtr<User> user, Scrobbler scrobbler);
// Accessors
ObjectPtr<Release> getRelease() const { return _release; }
ObjectPtr<User> getUser() const { return _user; }
Scrobbler getScrobbler() const { return _scrobbler; }
const Wt::WDateTime& getDateTime() const { return _dateTime; }
// Setters
void setDateTime(const Wt::WDateTime& dateTime);
template<class Action>
void persist(Action& a)
{
Wt::Dbo::field(a, _scrobbler, "scrobbler");
Wt::Dbo::field(a, _dateTime, "date_time");
Wt::Dbo::belongsTo(a, _release, "release", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::belongsTo(a, _user, "user", Wt::Dbo::OnDeleteCascade);
}
private:
Scrobbler _scrobbler; // for which scrobbler
Wt::WDateTime _dateTime; // when it was starred
Wt::Dbo::ptr<Release> _release;
Wt::Dbo::ptr<User> _user;
};
} // namespace Database
src/libs/services/database/include/services/database/StarredTrack.hpp
+81
View File
@@ -0,0 +1,81 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <Wt/WDateTime.h>
#include <Wt/Dbo/Dbo.h>
#include "services/database/TrackId.hpp"
#include "services/database/IdType.hpp"
#include "services/database/Object.hpp"
#include "services/database/Session.hpp"
#include "services/database/Types.hpp"
#include "services/database/UserId.hpp"
LMS_DECLARE_IDTYPE(StarredTrackId)
namespace Database
{
class Track;
class Session;
class User;
class StarredTrack : public Object<StarredTrack, StarredTrackId>
{
public:
StarredTrack() = default;
StarredTrack(ObjectPtr<Track> track, ObjectPtr<User> user, Scrobbler scrobbler);
// Search utility
static std::size_t getCount(Session& session);
static pointer find(Session& session, StarredTrackId id);
static pointer find(Session& session, TrackId trackId, UserId userId, Scrobbler scrobbler);
// Create utility
static pointer create(Session& session, ObjectPtr<Track> track, ObjectPtr<User> user, Scrobbler scrobbler);
// Accessors
ObjectPtr<Track> getTrack() const { return _track; }
ObjectPtr<User> getUser() const { return _user; }
Scrobbler getScrobbler() const { return _scrobbler; }
const Wt::WDateTime& getDateTime() const { return _dateTime; }
// Setters
void setDateTime(const Wt::WDateTime& dateTime);
template<class Action>
void persist(Action& a)
{
Wt::Dbo::field(a, _scrobbler, "scrobbler");
Wt::Dbo::field(a, _dateTime, "date_time");
Wt::Dbo::belongsTo(a, _track, "track", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::belongsTo(a, _user, "user", Wt::Dbo::OnDeleteCascade);
}
private:
Scrobbler _scrobbler; // for which scrobbler
Wt::WDateTime _dateTime; // when it was starred
Wt::Dbo::ptr<Track> _track;
Wt::Dbo::ptr<User> _user;
};
} // namespace Database
src/libs/services/database/include/services/database/Track.hpp
+39 -43
View File
@@ -34,7 +34,12 @@
#include "utils/EnumSet.hpp"
#include "utils/UUID.hpp"
#include "services/database/ArtistId.hpp"
#include "services/database/ClusterId.hpp"
#include "services/database/Object.hpp"
#include "services/database/TrackId.hpp"
#include "services/database/Types.hpp"
#include "services/database/UserId.hpp"
namespace Database {
@@ -44,50 +49,51 @@ class ClusterType;
class Release;
class Session;
class TrackArtistLink;
class TrackFeatures;
class TrackListEntry;
class TrackStats;
class User;
class Track : public Object<Track, TrackId>
{
public:
struct FindParameters
{
std::vector<ClusterId> clusters; // if non empty, tracks that belong to these clusters
std::vector<std::string_view> keywords; // if non empty, name must match all of these keywords
TrackSortMethod sortMethod {TrackSortMethod::None};
Range range;
Wt::WDateTime writtenAfter;
UserId starringUser; // only tracks starred by this user
std::optional<Scrobbler> scrobbler; // and for this scrobbler
FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; }
FindParameters& setKeywords(const std::vector<std::string_view>& _keywords) { keywords = _keywords; return *this; }
FindParameters& setSortMethod(TrackSortMethod _method) { sortMethod = _method; return *this; }
FindParameters& setRange(Range _range) { range = _range; return *this; }
FindParameters& setWrittenAfter(const Wt::WDateTime& _after) { writtenAfter = _after; return *this; }
FindParameters& setStarringUser(UserId _user, Scrobbler _scrobbler) { starringUser = _user; scrobbler = _scrobbler; return *this; }
};
struct PathResult
{
TrackId trackId;
std::filesystem::path path;
};
Track() = default;
Track(const std::filesystem::path& p);
// Find utility functions
static std::size_t getCount(Session& session);
static pointer getByPath(Session& session, const std::filesystem::path& p);
static pointer getById(Session& session, TrackId id);
static bool exists(Session& session, TrackId id);
static std::vector<pointer> getByRecordingMBID(Session& session, const UUID& MBID);
static std::vector<pointer> getSimilarTracks(Session& session,
const std::vector<TrackId>& trackIds,
std::optional<std::size_t> offset = {},
std::optional<std::size_t> size = {});
static std::vector<pointer> getByClusters(Session& session,
const std::vector<ClusterId>& clusters); // tracks that belong to these clusters
static std::vector<pointer> getByFilter(Session& session,
const std::vector<ClusterId>& clusters, // if non empty, tracks that belong to these clusters
const std::vector<std::string_view>& keywords, // if non empty, name must match all of these keywords
std::optional<Range> range,
bool& moreExpected);
static std::vector<pointer> getByNameAndReleaseName(Session& session, std::string_view trackName, std::string_view releaseName);
static std::size_t getCount(Session& session);
static pointer findByPath(Session& session, const std::filesystem::path& p);
static pointer find(Session& session, TrackId id);
static bool exists(Session& session, TrackId id);
static std::vector<pointer> findByRecordingMBID(Session& session, const UUID& MBID);
static RangeResults<TrackId> findSimilarTracks(Session& session, const std::vector<TrackId>& trackIds, Range range);
static std::vector<pointer> getAll(Session& session, std::optional<std::size_t> limit = std::nullopt);
static std::vector<pointer> getAllRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<std::size_t> limit = std::nullopt);
static std::vector<TrackId> getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<std::size_t> limit = std::nullopt);
static std::vector<TrackId> getAllIds(Session& session);
static std::vector<std::pair<TrackId, std::filesystem::path>> getAllPaths(Session& session, std::optional<std::size_t> offset = std::nullopt, std::optional<std::size_t> size = std::nullopt);
static std::vector<pointer> getMBIDDuplicates(Session& session);
static std::vector<pointer> getLastWritten(Session& session, std::optional<Wt::WDateTime> after, const std::vector<ClusterId>& clusters, std::optional<Range> range, bool& moreResults);
static std::vector<pointer> getAllWithRecordingMBIDAndMissingFeatures(Session& session);
static std::vector<TrackId> getAllIdsWithFeatures(Session& session, std::optional<std::size_t> limit = {});
static std::vector<TrackId> getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit = {});
static std::vector<pointer> getStarred(Session& session,
ObjectPtr<User> user,
const std::vector<ClusterId>& clusters,
std::optional<Range> range, bool& hasMore);
static RangeResults<TrackId> find(Session& session, const FindParameters& parameters);
static RangeResults<TrackId> findByNameAndReleaseName(Session& session, std::string_view trackName, std::string_view releaseName);
static RangeResults<PathResult> findPaths(Session& session, Range range);
static RangeResults<TrackId> findMBIDDuplicates(Session& session, Range range);
static RangeResults<TrackId> findWithRecordingMBIDAndMissingFeatures(Session& session, Range range);
// Create utility
static pointer create(Session& session, const std::filesystem::path& p);
@@ -116,7 +122,6 @@ class Track : public Object<Track, TrackId>
void addArtistLink(const ObjectPtr<TrackArtistLink>& artistLink);
void setRelease(ObjectPtr<Release> release) { _release = getDboPtr(release); }
void setClusters(const std::vector<ObjectPtr<Cluster>>& clusters );
void setFeatures(const ObjectPtr<TrackFeatures>& features);
std::size_t getScanVersion() const { return _scanVersion; }
std::optional<std::size_t> getTrackNumber() const;
@@ -147,8 +152,6 @@ class Track : public Object<Track, TrackId>
ObjectPtr<Release> getRelease() const { return _release; }
std::vector<ObjectPtr<Cluster>> getClusters() const;
std::vector<ClusterId> getClusterIds() const;
bool hasTrackFeatures() const;
ObjectPtr<TrackFeatures> getTrackFeatures() const;
std::vector<std::vector<ObjectPtr<Cluster>>> getClusterGroups(const std::vector<ObjectPtr<ClusterType>>& clusterTypes, std::size_t size) const;
@@ -178,9 +181,6 @@ class Track : public Object<Track, TrackId>
Wt::Dbo::belongsTo(a, _release, "release", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _trackArtistLinks, Wt::Dbo::ManyToOne, "track");
Wt::Dbo::hasMany(a, _clusters, Wt::Dbo::ManyToMany, "track_cluster", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _playlistEntries, Wt::Dbo::ManyToOne, "track");
Wt::Dbo::hasMany(a, _starringUsers, Wt::Dbo::ManyToMany, "user_track_starred", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasOne(a, _trackFeatures);
}
private:
@@ -215,10 +215,6 @@ class Track : public Object<Track, TrackId>
Wt::Dbo::ptr<Release> _release;
Wt::Dbo::collection<Wt::Dbo::ptr<TrackArtistLink>> _trackArtistLinks;
Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> _clusters;
Wt::Dbo::collection<Wt::Dbo::ptr<TrackListEntry>> _playlistEntries;
Wt::Dbo::collection<Wt::Dbo::ptr<User>> _starringUsers;
Wt::Dbo::weak_ptr<TrackFeatures> _trackFeatures;
};
} // namespace database
src/libs/services/database/include/services/database/TrackArtistLink.hpp
+6 -3
View File
@@ -23,9 +23,13 @@
#include <Wt/Dbo/Dbo.h>
#include "services/database/IdType.hpp"
#include "services/database/Object.hpp"
#include "services/database/Types.hpp"
#include "utils/EnumSet.hpp"
LMS_DECLARE_IDTYPE(TrackArtistLinkId)
namespace Database
{
@@ -40,11 +44,10 @@ namespace Database
TrackArtistLink(ObjectPtr<Track> track, ObjectPtr<Artist> artist, TrackArtistLinkType type);
static pointer create(Session& session, ObjectPtr<Track> track, ObjectPtr<Artist> artist, TrackArtistLinkType type);
static EnumSet<TrackArtistLinkType> getUsedTypes(Session& session);
static EnumSet<TrackArtistLinkType> findUsedTypes(Session& session);
ObjectPtr<Track> getTrack() const { return _track; }
ObjectPtr<Artist> getArtist() const { return _artist; }
ObjectPtr<Artist> getArtist() const { return _artist; }
TrackArtistLinkType getType() const { return _type; }
template<class Action>
src/libs/services/database/include/services/database/TrackBookmark.hpp
+13 -7
View File
@@ -23,7 +23,13 @@
#include <Wt/Dbo/Dbo.h>
#include "services/database/IdType.hpp"
#include "services/database/Object.hpp"
#include "services/database/TrackId.hpp"
#include "services/database/Types.hpp"
#include "services/database/UserId.hpp"
LMS_DECLARE_IDTYPE(TrackBookmarkId)
namespace Database {
@@ -41,10 +47,10 @@ class TrackBookmark : public Object<TrackBookmark, TrackBookmarkId>
static pointer create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track);
// Find utility functions
static std::vector<pointer> getAll(Session& session);
static std::vector<pointer> getByUser(Session& session, ObjectPtr<User> user);
static pointer getByUser(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track);
static pointer getById(Session& session, TrackBookmarkId id);
static std::size_t getCount(Session& session);
static pointer find(Session& session, TrackBookmarkId id);
static RangeResults<TrackBookmarkId> find(Session& session, UserId userId, Range range);
static pointer find(Session& session, UserId userId, TrackId trackId);
// Setters
void setOffset(std::chrono::milliseconds offset) { _offset = offset; }
@@ -52,9 +58,9 @@ class TrackBookmark : public Object<TrackBookmark, TrackBookmarkId>
// Getters
std::chrono::milliseconds getOffset() const { return _offset; }
std::string_view getComment() const { return _comment; }
ObjectPtr<Track> getTrack() const { return _track; }
ObjectPtr<User> getUser() const { return _user; }
std::string_view getComment() const { return _comment; }
ObjectPtr<Track> getTrack() const { return _track; }
ObjectPtr<User> getUser() const { return _user; }
template<class Action>
void persist(Action& a)
src/libs/services/database/include/services/database/TrackFeatures.hpp
+15 -2
View File
@@ -26,8 +26,13 @@
#include <Wt/Dbo/Dbo.h>
#include "services/database/IdType.hpp"
#include "services/database/Object.hpp"
#include "services/database/TrackId.hpp"
#include "services/database/Types.hpp"
LMS_DECLARE_IDTYPE(TrackFeaturesId)
namespace Database {
class Session;
@@ -43,12 +48,21 @@ class TrackFeatures : public Object<TrackFeatures, TrackFeaturesId>
TrackFeatures() = default;
TrackFeatures(ObjectPtr<Track> track, const std::string& jsonEncodedFeatures);
// Find utilities
static std::size_t getCount(Session& session);
static pointer find(Session& session, TrackFeaturesId id);
static pointer find(Session& session, TrackId trackId);
static RangeResults<TrackFeaturesId> find(Session& session, Range range);
// Create utility
static pointer create(Session& session, ObjectPtr<Track> track, const std::string& jsonEncodedFeatures);
static pointer create(Session& session, ObjectPtr<Track> track, const std::string& jsonEncodedFeatures);
FeatureValues getFeatureValues(const FeatureName& feature) const;
FeatureValuesMap getFeatureValuesMap(const std::unordered_set<FeatureName>& featureNames) const;
// Accessors
Wt::Dbo::ptr<Track> getTrack() const { return _track; }
template<class Action>
void persist(Action& a)
{
@@ -57,7 +71,6 @@ class TrackFeatures : public Object<TrackFeatures, TrackFeaturesId>
}
private:
std::string _data;
Wt::Dbo::ptr<Track> _track;
};
src/libs/services/database/include/services/database/TrackId.hpp
+25
View File
@@ -0,0 +1,25 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "services/database/IdType.hpp"
LMS_DECLARE_IDTYPE(TrackId)
src/libs/services/database/include/services/database/TrackList.hpp
+31 -23
View File
@@ -21,13 +21,18 @@
#include <optional>
#include <string>
#include <set>
#include <string_view>
#include <vector>
#include <Wt/Dbo/Dbo.h>
#include <Wt/WDateTime.h>
#include "services/database/ClusterId.hpp"
#include "services/database/Object.hpp"
#include "services/database/TrackId.hpp"
#include "services/database/TrackListId.hpp"
#include "services/database/Types.hpp"
#include "services/database/UserId.hpp"
namespace Database {
@@ -52,25 +57,25 @@ class TrackList : public Object<TrackList, TrackListId>
TrackList(std::string_view name, Type type, bool isPublic, ObjectPtr<User> user);
// Stats utility
std::vector<ObjectPtr<Artist>> getTopArtists(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
std::vector<ObjectPtr<Release>> getTopReleases(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
std::vector<ObjectPtr<Track>> getTopTracks(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
std::vector<ObjectPtr<Artist>> getTopArtists(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
std::vector<ObjectPtr<Release>> getTopReleases(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
std::vector<ObjectPtr<Track>> getTopTracks(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
// Search utility
static pointer get(Session& session, std::string_view name, Type type, ObjectPtr<User> user);
static pointer getById(Session& session, TrackListId tracklistId);
static std::vector<pointer> getAll(Session& session);
static std::vector<pointer> getAll(Session& session, ObjectPtr<User> user);
static std::vector<pointer> getAll(Session& session, ObjectPtr<User> user, Type type);
static std::size_t getCount(Session& session);
static pointer find(Session& session, std::string_view name, Type type, UserId userId);
static pointer find(Session& session, TrackListId tracklistId);
static RangeResults<TrackListId> find(Session& session, UserId userId, Range range);
static RangeResults<TrackListId> find(Session& session, UserId userId, Type type, Range range);
// Create utility
static pointer create(Session& session, std::string_view name, Type type, bool isPublic, ObjectPtr<User> user);
// Accessors
std::string getName() const { return _name; }
bool isPublic() const { return _isPublic; }
Type getType() const { return _type; }
ObjectPtr<User> getUser() const { return _user; }
std::string_view getName() const { return _name; }
bool isPublic() const { return _isPublic; }
Type getType() const { return _type; }
ObjectPtr<User> getUser() const { return _user; }
// Modifiers
void setName(const std::string& name) { _name = name; }
@@ -81,18 +86,20 @@ class TrackList : public Object<TrackList, TrackListId>
bool isEmpty() const;
std::size_t getCount() const;
ObjectPtr<TrackListEntry> getEntry(std::size_t pos) const;
std::vector<ObjectPtr<TrackListEntry>> getEntries(std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {}) const;
std::vector<ObjectPtr<TrackListEntry>> getEntries(std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {}) const;
ObjectPtr<TrackListEntry> getEntryByTrackAndDateTime(ObjectPtr<Track> track, const Wt::WDateTime& dateTime) const;
// Get track bya
std::vector<ObjectPtr<Artist>> getArtists(const std::vector<ClusterId>& clusters, std::optional<TrackArtistLinkType> linkType, ArtistSortMethod sortMethod, std::optional<Range> range, bool& moreResults) const;
std::vector<ObjectPtr<Release>> getReleases(const std::vector<ClusterId>& clusters, std::optional<Range> range, bool& moreResults) const;
std::vector<ObjectPtr<Track>> getTracks(const std::vector<ClusterId>& clusters, std::optional<Range> range, bool& moreResults) const;
std::vector<ObjectPtr<Artist>> getArtistsReverse(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
std::vector<ObjectPtr<Release>> getReleasesReverse(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
std::vector<ObjectPtr<Track>> getTracksReverse(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
// Sorted by date time
std::vector<ObjectPtr<Artist>> getArtistsOrderedByRecentFirst(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
std::vector<ObjectPtr<Release>> getReleasesOrderedByRecentFirst(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
std::vector<ObjectPtr<Track>> getTracksOrderedByRecentFirst(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
std::vector<TrackId> getTrackIds() const;
std::chrono::milliseconds getDuration() const;
std::vector<TrackId> getTrackIds() const;
std::chrono::milliseconds getDuration() const;
// Get clusters, order by occurence
std::vector<ObjectPtr<Cluster>> getClusters() const;
@@ -129,12 +136,13 @@ class TrackListEntry : public Object<TrackListEntry, TrackListEntryId>
public:
TrackListEntry() = default;
TrackListEntry(ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist, const Wt::WDateTime& dateTime);
TrackListEntry(ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist);
// find utility
static pointer getById(Session& session, TrackListEntryId id);
// Create utility
static pointer create(Session& session, ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist, const Wt::WDateTime& dateTime = Wt::WDateTime::currentDateTime());
static pointer create(Session& session, ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist, const Wt::WDateTime& dateTime = {});
// Accessors
ObjectPtr<Track> getTrack() const { return _track; }
@@ -151,7 +159,7 @@ class TrackListEntry : public Object<TrackListEntry, TrackListEntryId>
private:
Wt::WDateTime _dateTime;
Wt::WDateTime _dateTime; // optional date time
Wt::Dbo::ptr<Track> _track;
Wt::Dbo::ptr<TrackList> _tracklist;
};
src/libs/services/database/include/services/database/TrackListId.hpp
+26
View File
@@ -0,0 +1,26 @@
/*
* Copyright (C) 2014 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "services/database/IdType.hpp"
LMS_DECLARE_IDTYPE(TrackListId)
LMS_DECLARE_IDTYPE(TrackListEntryId)
src/libs/services/database/include/services/database/Types.hpp
+109 -109
View File
@@ -22,63 +22,126 @@
#include <cstdint>
#include <cassert>
#include <functional>
#include <Wt/Dbo/ptr.h>
#include <Wt/WDate.h>
namespace Database
{
class IdType
{
public:
using ValueType = Wt::Dbo::dbo_default_traits::IdType;
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); }
ValueType getValue() const { return _id; }
bool operator==(IdType other) const { return other._id == _id; }
bool operator!=(IdType other) const { return !(*this == other); }
bool operator<(IdType other) const { return other._id < _id; }
private:
Wt::Dbo::dbo_default_traits::IdType _id {Wt::Dbo::dbo_default_traits::invalidId()};
};
// Caution: do not change enum values if they are set!
// Request:
// size = 0 => no size limit!
// Response (via RangeResults)
// size => results size
struct Range
{
std::size_t offset {};
std::size_t limit {};
std::size_t size {};
// TODO remove this
operator bool() const { return size != 0; }
};
template <typename T>
struct RangeResults
{
Range range;
std::vector<T> results;
bool moreResults;
RangeResults getSubRange(Range subRange)
{
assert(subRange.offset >= range.offset);
if (!subRange.size)
subRange.size = range.size - (subRange.offset - range.offset);
subRange.offset = std::min(subRange.offset, range.offset + range.size);
subRange.size = std::min(subRange.size, range.offset + range.size - subRange.offset);
RangeResults subResults;
auto itBegin {std::cbegin(results) + subRange.offset - range.offset};
auto itEnd {itBegin + subRange.size};
subResults.results.reserve(std::distance(itBegin, itEnd));
std::copy(itBegin, itEnd, std::back_inserter(subResults.results));
subResults.range = subRange;
if (subRange.offset + subRange.size == range.offset + range.size)
subResults.moreResults = moreResults;
else
subResults.moreResults = true;
return subResults;
}
};
struct DateRange
{
Wt::WDate begin;
Wt::WDate end;
static DateRange fromYearRange(int from, int to);
};
enum class ArtistSortMethod
{
None,
ByName,
BySortName,
Random,
LastWritten,
StarredDateDesc,
};
enum class ReleaseSortMethod
{
None,
Name,
Date,
Random,
LastWritten,
StarredDateDesc,
};
enum class TrackSortMethod
{
None,
Random,
LastWritten,
StarredDateDesc,
};
// Do not change enum values!
enum class TrackArtistLinkType
{
Artist, // regular artist
Arranger,
Composer,
Conductor,
Lyricist,
Mixer,
Performer,
Producer,
ReleaseArtist,
Remixer,
Writer,
Artist = 0, // regular track artist
Arranger = 1,
Composer = 2,
Conductor = 3,
Lyricist = 4,
Mixer = 5,
Performer = 6,
Producer = 7,
ReleaseArtist = 8,
Remixer = 9,
Writer = 10,
};
// User selectable audio file formats
// Do not change values
enum class AudioFormat
{
MP3 = 1,
OGG_OPUS = 2,
OGG_VORBIS = 3,
WEBM_VORBIS = 4,
MP3 = 1,
OGG_OPUS = 2,
OGG_VORBIS = 3,
WEBM_VORBIS = 4,
MATROSKA_OPUS = 5,
};
using Bitrate = std::uint32_t;
// Do not remove values!
void visitAllowedAudioBitrates(std::function<void(Bitrate)>);
bool isAudioBitrateAllowed(Bitrate bitrate);
// Do not change enum values!
enum class Scrobbler
@@ -95,82 +158,19 @@ namespace Database
DEMO = 2,
};
template <typename T>
class ObjectPtr
// Do not change enum values!
enum class UITheme
{
public:
ObjectPtr() = default;
ObjectPtr(Wt::Dbo::ptr<T> obj) : _obj {obj} {}
const T* operator->() const { return _obj.get(); }
operator bool() const { return _obj.get(); }
bool operator!() const { return !_obj.get(); }
auto modify() { return _obj.modify(); }
void remove() { _obj.remove(); }
private:
template <typename, typename> friend class Object;
Wt::Dbo::ptr<T> _obj;
Light = 0,
Dark = 1,
};
template <typename T, typename ObjectIdType>
class Object : public Wt::Dbo::Dbo<T>
// Do not change enum values!
enum class SubsonicArtistListMode
{
static_assert(std::is_base_of_v<Database::IdType, ObjectIdType>);
static_assert(!std::is_same_v<Database::IdType, ObjectIdType>);
public:
using pointer = ObjectPtr<T>;
using IdType = ObjectIdType;
IdType getId() const { return Wt::Dbo::Dbo<T>::self()->Wt::Dbo::template Dbo<T>::id(); }
// catch some misuses
typename Wt::Dbo::dbo_traits<T>::IdType id() const = delete;
protected:
// Can get raw dbo ptr only from Objects
template <typename SomeObject>
static
Wt::Dbo::ptr<SomeObject> getDboPtr(ObjectPtr<SomeObject> ptr) { return ptr._obj; }
AllArtists = 0,
ReleaseArtists = 1,
TrackArtists = 2,
};
}
// TODO factorize hash with std::enable_if
#define LMS_DECLARE_IDTYPE(name) \
namespace Database { \
class name : public IdType \
{ \
public: \
using IdType::IdType; \
};\
} \
namespace std \
{ \
template<> \
class hash<Database::name> \
{ \
public: \
size_t operator()(Database::name id) const \
{ \
return std::hash<Database::name::ValueType>()(id.getValue()); \
} \
}; \
} // ns std
LMS_DECLARE_IDTYPE(ArtistId)
LMS_DECLARE_IDTYPE(AuthTokenId)
LMS_DECLARE_IDTYPE(ClusterId)
LMS_DECLARE_IDTYPE(ClusterTypeId)
LMS_DECLARE_IDTYPE(ReleaseId)
LMS_DECLARE_IDTYPE(ScanSettingsId)
LMS_DECLARE_IDTYPE(TrackArtistLinkId)
LMS_DECLARE_IDTYPE(TrackBookmarkId)
LMS_DECLARE_IDTYPE(TrackFeaturesId)
LMS_DECLARE_IDTYPE(TrackId)
LMS_DECLARE_IDTYPE(TrackListId)
LMS_DECLARE_IDTYPE(TrackListEntryId)
LMS_DECLARE_IDTYPE(UserId)
src/libs/services/database/include/services/database/User.hpp
+15 -102
View File
@@ -26,51 +26,15 @@
#include <Wt/Dbo/Dbo.h>
#include <Wt/WDateTime.h>
#include "services/database/Object.hpp"
#include "services/database/Types.hpp"
#include "services/database/UserId.hpp"
#include "utils/UUID.hpp"
namespace Database {
class Artist;
class Release;
class AuthToken;
class Session;
class TrackList;
class Track;
class User;
class AuthToken : public Object<AuthToken, AuthTokenId>
{
public:
AuthToken() = default;
AuthToken(const std::string& value, const Wt::WDateTime& expiry, ObjectPtr<User> user);
// Utility
static pointer create(Session& session, const std::string& value, const Wt::WDateTime&expiry, ObjectPtr<User> user);
static void removeExpiredTokens(Session& session, const Wt::WDateTime& now);
static pointer getByValue(Session& session, const std::string& value);
static pointer getById(Session& session, AuthTokenId tokenId);
// Accessors
const Wt::WDateTime& getExpiry() const { return _expiry; }
ObjectPtr<User> getUser() const { return _user; }
const std::string& getValue() const { return _value; }
template<class Action>
void persist(Action& a)
{
Wt::Dbo::field(a, _value, "value");
Wt::Dbo::field(a, _expiry, "expiry");
Wt::Dbo::belongsTo(a, _user, "user", Wt::Dbo::OnDeleteCascade);
}
private:
std::string _value;
Wt::WDateTime _expiry;
Wt::Dbo::ptr<User> _user;
};
class User : public Object<User, UserId>
{
@@ -81,35 +45,10 @@ class User : public Object<User, UserId>
std::string hash;
};
// Do not change enum values!
enum class UITheme
{
Light = 0,
Dark = 1,
};
// Do not remove values!
static inline const std::set<Bitrate> audioTranscodeAllowedBitrates
{
64000,
96000,
128000,
192000,
320000,
};
// Do not change enum values!
enum class SubsonicArtistListMode
{
AllArtists = 0,
ReleaseArtists = 1,
TrackArtists = 2,
};
static inline const std::size_t MinNameLength {3};
static inline const std::size_t MaxNameLength {15};
static inline const bool defaultSubsonicTranscodeEnable {true};
static inline const AudioFormat defaultSubsonicTranscodeFormat {AudioFormat::OGG_OPUS};
static inline const AudioFormat defaultSubsonicTranscodeFormat {AudioFormat::OGG_OPUS};
static inline const Bitrate defaultSubsonicTranscodeBitrate {128000};
static inline const UITheme defaultUITheme {UITheme::Dark};
static inline const SubsonicArtistListMode defaultSubsonicArtistListMode {SubsonicArtistListMode::AllArtists};
@@ -121,18 +60,17 @@ class User : public Object<User, UserId>
// utility
static pointer create(Session& session, std::string_view loginName);
static pointer getById(Session& session, UserId id);
static pointer getByLoginName(Session& session, std::string_view loginName);
static std::vector<pointer> getAll(Session& session);
static std::vector<UserId> getAllIds(Session& session);
static pointer getDemo(Session& session);
static std::size_t getCount(Session& session);
static std::size_t getCount(Session& session);
static pointer find(Session& session, UserId id);
static pointer find(Session& session, std::string_view loginName);
static RangeResults<UserId> find(Session& session, Range range);
static pointer findDemoUser(Session& session);
// accessors
const std::string& getLoginName() const { return _loginName; }
PasswordHash getPasswordHash() const { return PasswordHash {_passwordSalt, _passwordHash}; }
Wt::WDateTime getLastLogin() const { return _lastLogin; }
std::size_t getAuthTokensCount() const { return _authTokens.size(); }
const std::string& getLoginName() const { return _loginName; }
PasswordHash getPasswordHash() const { return PasswordHash {_passwordSalt, _passwordHash}; }
const Wt::WDateTime& getLastLogin() const { return _lastLogin; }
std::size_t getAuthTokensCount() const { return _authTokens.size(); }
// write
void setLastLogin(const Wt::WDateTime& dateTime) { _lastLogin = dateTime; }
@@ -165,21 +103,6 @@ class User : public Object<User, UserId>
Scrobbler getScrobbler() const { return _scrobbler; }
std::optional<UUID> getListenBrainzToken() const { return UUID::fromString(_listenbrainzToken); }
ObjectPtr<TrackList> getQueuedTrackList(Session& session) const;
void star(ObjectPtr<Artist> artist);
void unstar(ObjectPtr<Artist> artist);
bool isStarred(ObjectPtr<Artist> artist) const;
void star(ObjectPtr<Release> release);
void unstar(ObjectPtr<Release> release);
bool isStarred(ObjectPtr<Release> release) const;
// Stars
void star(ObjectPtr<Track> track);
void unstar(ObjectPtr<Track> track);
bool isStarred(ObjectPtr<Track> track) const;
template<class Action>
void persist(Action& a)
{
@@ -196,20 +119,15 @@ class User : public Object<User, UserId>
Wt::Dbo::field(a, _scrobbler, "scrobbler");
Wt::Dbo::field(a, _listenbrainzToken, "listenbrainz_token");
// UI settings
// UI player settings
Wt::Dbo::field(a, _curPlayingTrackPos, "cur_playing_track_pos");
Wt::Dbo::field(a, _repeatAll, "repeat_all");
Wt::Dbo::field(a, _radio, "radio");
Wt::Dbo::hasMany(a, _tracklists, Wt::Dbo::ManyToOne, "user");
Wt::Dbo::hasMany(a, _starredArtists, Wt::Dbo::ManyToMany, "user_artist_starred", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _starredReleases, Wt::Dbo::ManyToMany, "user_release_starred", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _starredTracks, Wt::Dbo::ManyToMany, "user_track_starred", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _authTokens, Wt::Dbo::ManyToOne, "user");
}
private:
std::string _loginName;
std::string _passwordSalt;
std::string _passwordHash;
@@ -228,16 +146,11 @@ class User : public Object<User, UserId>
int _subsonicTranscodeBitrate {defaultSubsonicTranscodeBitrate};
// User's dynamic data (UI)
int _curPlayingTrackPos {}; // Current track position in queue
int _curPlayingTrackPos {}; // Current track position in queue
bool _repeatAll {};
bool _radio {};
Wt::Dbo::collection<Wt::Dbo::ptr<TrackList>> _tracklists;
Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> _starredArtists;
Wt::Dbo::collection<Wt::Dbo::ptr<Release>> _starredReleases;
Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _starredTracks;
Wt::Dbo::collection<Wt::Dbo::ptr<AuthToken>> _authTokens;
};
} // namespace Databas'
src/libs/services/database/include/services/database/UserId.hpp
+25
View File
@@ -0,0 +1,25 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "services/database/IdType.hpp"
LMS_DECLARE_IDTYPE(UserId)
src/libs/services/database/test/Artist.cpp
+68 -116
View File
@@ -21,13 +21,14 @@
using namespace Database;
TEST_F(DatabaseFixture, SingleArtist)
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);
}
ScopedArtist artist {session, "MyArtist"};
@@ -40,22 +41,23 @@ TEST_F(DatabaseFixture, SingleArtist)
EXPECT_EQ(artist.get()->getId(), artist.getId());
EXPECT_TRUE(Artist::exists(session, artist.getId()));
EXPECT_EQ(Artist::getCount(session), 1);
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Artist::getAll(session, Artist::SortMethod::ByName)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
auto artists {Artist::find(session, Artist::FindParameters {})};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
artists = Artist::getAllOrphans(session);
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
artists = Artist::findAllOrphans(session, Range {});
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
}
}
TEST_F(DatabaseFixture, SingleTrackSingleArtist)
TEST_F(DatabaseFixture, Artist_singleTrack)
{
ScopedTrack track {session, "MyTrack"};
ScopedArtist artist {session, "MyArtist"};
@@ -68,7 +70,7 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtist)
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Artist::getAllOrphans(session).empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
}
{
@@ -102,7 +104,7 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtist)
}
}
TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiRoles)
TEST_F(DatabaseFixture, Artist_singleTracktMultiRoles)
{
ScopedTrack track {session, "MyTrack"};
ScopedArtist artist {session, "MyArtist"};
@@ -116,17 +118,16 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiRoles)
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Artist::getAllOrphans(session).empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
}
{
auto transaction {session.createSharedTransaction()};
bool hasMore{};
EXPECT_EQ(Artist::getByFilter(session, {}, {}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, hasMore).size(), 1);
EXPECT_EQ(Artist::getByFilter(session, {}, {}, TrackArtistLinkType::Artist, Artist::SortMethod::ByName, std::nullopt, hasMore).size(), 1);
EXPECT_EQ(Artist::getByFilter(session, {}, {}, TrackArtistLinkType::ReleaseArtist, Artist::SortMethod::ByName, std::nullopt, hasMore).size(), 1);
EXPECT_EQ(Artist::getByFilter(session, {}, {}, TrackArtistLinkType::Writer, Artist::SortMethod::ByName, std::nullopt, hasMore).size(), 1);
EXPECT_TRUE(Artist::getByFilter(session, {}, {}, TrackArtistLinkType::Composer, Artist::SortMethod::ByName, std::nullopt, hasMore).empty());
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);
}
{
@@ -149,7 +150,7 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiRoles)
}
}
TEST_F(DatabaseFixture,SingleTrackMultiArtists)
TEST_F(DatabaseFixture, Artist_singleTrackMultiArtists)
{
ScopedTrack track {session, "track"};
ScopedArtist artist1 {session, "artist1"};
@@ -165,7 +166,7 @@ TEST_F(DatabaseFixture,SingleTrackMultiArtists)
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Artist::getAllOrphans(session).empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
}
{
@@ -179,8 +180,8 @@ TEST_F(DatabaseFixture,SingleTrackMultiArtists)
EXPECT_EQ(track->getArtists({}).size(), 2);
EXPECT_EQ(track->getArtists({TrackArtistLinkType::Artist}).size(), 2);
EXPECT_TRUE(track->getArtists({TrackArtistLinkType::ReleaseArtist}).empty());
EXPECT_EQ(Artist::getAll(session, Artist::SortMethod::ByName).size(), 2);
EXPECT_EQ(Artist::getAllIds(session).size(), 2);
EXPECT_EQ(Artist::find(session, Artist::FindParameters {}).results.size(), 2);
EXPECT_EQ(Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::Random)).results.size(), 2);
}
{
@@ -196,7 +197,7 @@ TEST_F(DatabaseFixture,SingleTrackMultiArtists)
}
}
TEST_F(DatabaseFixture, SingleArtistSearchByName)
TEST_F(DatabaseFixture, Artist_findByName)
{
ScopedArtist artist {session, "AAA"};
ScopedTrack track {session, "MyTrack"}; // filters does not work on orphans
@@ -210,22 +211,22 @@ TEST_F(DatabaseFixture, SingleArtistSearchByName)
{
auto transaction {session.createSharedTransaction()};
bool more {};
EXPECT_TRUE(Artist::getByFilter(session, {}, {"N"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more).empty());
EXPECT_TRUE(Artist::find(session, Artist::FindParameters {}.setKeywords({"N"})).results.empty());
const auto artistsByAAA {Artist::Artist::getByFilter(session, {}, {"A"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
ASSERT_EQ(artistsByAAA.size(), 1);
EXPECT_EQ(artistsByAAA.front()->getId(), 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::getByFilter(session, {}, {"Z"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
ASSERT_EQ(artistsByZZZ.size(), 1);
EXPECT_EQ(artistsByZZZ.front()->getId(), 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::getByName(session, "NNN").empty());
EXPECT_TRUE(Artist::find(session, "NNN").empty());
EXPECT_EQ(Artist::find(session, "AAA").size(), 1);
}
}
TEST_F(DatabaseFixture, MultipleArtistsSearchByNameEscaped)
TEST_F(DatabaseFixture, Artist_findByNameEscaped)
{
ScopedArtist artist1 {session, "MyArtist%"};
ScopedArtist artist2 {session, "%MyArtist"};
@@ -238,70 +239,55 @@ TEST_F(DatabaseFixture, MultipleArtistsSearchByNameEscaped)
{
auto transaction {session.createSharedTransaction()};
{
const auto artists {Artist::getByName(session, "MyArtist%")};
const auto artists {Artist::find(session, "MyArtist%")};
ASSERT_TRUE(artists.size() == 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
EXPECT_TRUE(Artist::getByName(session, "MyArtistFoo").empty());
EXPECT_TRUE(Artist::find(session, "MyArtistFoo").empty());
}
{
const auto artists {Artist::getByName(session, "%MyArtist")};
const auto artists {Artist::find(session, "%MyArtist")};
ASSERT_TRUE(artists.size() == 1);
EXPECT_EQ(artists.front()->getId(), artist2.getId());
EXPECT_TRUE(Artist::getByName(session, "FooMyArtist").empty());
EXPECT_TRUE(Artist::find(session, "FooMyArtist").empty());
}
{
const auto artists {Artist::getByName(session, "%_MyArtist")};
const auto artists {Artist::find(session, "%_MyArtist")};
ASSERT_TRUE(artists.size() == 1);
ASSERT_EQ(artists.front()->getId(), artist3.getId());
EXPECT_TRUE(Artist::getByName(session, "%CMyArtist").empty());
EXPECT_TRUE(Artist::find(session, "%CMyArtist").empty());
}
}
// get by filter only works with tracks links...
ScopedTrack track {session, "MyTrack"}; // filters does not work on orphans
{
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(), artist3.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track.get(), artist4.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track.get(), artist5.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track.get(), artist6.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
bool more;
{
const auto artists {Artist::getByFilter(session, {}, {"MyArtist"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
EXPECT_EQ(artists.size(), 6);
const auto artists {Artist::find(session, Artist::FindParameters {}.setKeywords({"MyArtist"}))};
EXPECT_EQ(artists.results.size(), 6);
}
{
const auto artists {Artist::getByFilter(session, {}, {"MyArtist%"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists[0]->getId(), artist1.getId());
EXPECT_EQ(artists[1]->getId(), 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::getByFilter(session, {}, {"%MyArtist"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists[0]->getId(), artist2.getId());
EXPECT_EQ(artists[1]->getId(), 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::getByFilter(session, {}, {"_MyArtist"}, std::nullopt, Artist::SortMethod::ByName, std::nullopt, more)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists[0]->getId(), 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, MultiArtistsSortMethod)
TEST_F(DatabaseFixture, Artist_sortMethod)
{
ScopedArtist artistA {session, "artistA"};
ScopedArtist artistB {session, "artistB"};
@@ -316,20 +302,20 @@ TEST_F(DatabaseFixture, MultiArtistsSortMethod)
{
auto transaction {session.createSharedTransaction()};
auto allArtistsByName {Artist::getAll(session, Artist::SortMethod::ByName)};
auto allArtistsBySortName {Artist::getAll(session, Artist::SortMethod::BySortName)};
auto allArtistsByName {Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::ByName))};
auto allArtistsBySortName {Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::BySortName))};
ASSERT_EQ(allArtistsByName.size(), 2);
EXPECT_EQ(allArtistsByName.front()->getId(), artistA.getId());
EXPECT_EQ(allArtistsByName.back()->getId(), 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.size(), 2);
EXPECT_EQ(allArtistsBySortName.front()->getId(), artistB.getId());
EXPECT_EQ(allArtistsBySortName.back()->getId(), 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, SingleArtistNonReleaseTracks)
TEST_F(DatabaseFixture, Artist_nonReleaseTracks)
{
ScopedArtist artist {session, "artist"};
ScopedTrack track1 {session, "MyTrack1"};
@@ -340,9 +326,8 @@ TEST_F(DatabaseFixture, SingleArtistNonReleaseTracks)
auto transaction {session.createSharedTransaction()};
EXPECT_FALSE(artist->hasNonReleaseTracks(std::nullopt));
bool moreResults;
const auto tracks {artist->getNonReleaseTracks(std::nullopt, std::nullopt, moreResults )};
EXPECT_EQ(tracks.size(), 0);
const auto tracks {artist->getNonReleaseTracks(std::nullopt, Range {})};
EXPECT_EQ(tracks.results.size(), 0);
}
{
@@ -358,44 +343,11 @@ TEST_F(DatabaseFixture, SingleArtistNonReleaseTracks)
{
auto transaction {session.createSharedTransaction()};
bool moreResults;
const auto tracks {artist->getNonReleaseTracks(std::nullopt, std::nullopt, moreResults )};
const auto tracks {artist->getNonReleaseTracks(std::nullopt, Range {})};
EXPECT_TRUE(artist->hasNonReleaseTracks(std::nullopt));
EXPECT_FALSE(moreResults);
ASSERT_EQ(tracks.size(), 1);
EXPECT_EQ(tracks.front()->getId(), track2.getId());
}
}
TEST_F(DatabaseFixture, SingleStarredArtist)
{
ScopedArtist artist {session, "MyArtist"};
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
{
auto transaction {session.createUniqueTransaction()};
EXPECT_FALSE(user->isStarred(artist.get()));
}
{
auto transaction {session.createUniqueTransaction()};
auto trackArtistLink {TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist)};
user.get().modify()->star(artist.get());
}
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(user->isStarred(artist.get()));
bool hasMore {};
auto artists {Artist::getStarred(session, user.get(), {}, std::nullopt, Artist::SortMethod::BySortName, std::nullopt, hasMore)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
EXPECT_FALSE(hasMore);
EXPECT_FALSE(tracks.moreResults);
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front()->getId(), track2.getId());
}
}
src/libs/services/database/test/CMakeLists.txt
+8
View File
@@ -2,9 +2,17 @@
add_executable(test-database
Artist.cpp
Cluster.cpp
Common.cpp
DatabaseTest.cpp
Listen.cpp
Release.cpp
StarredArtist.cpp
StarredRelease.cpp
StarredTrack.cpp
Track.cpp
TrackBookmark.cpp
TrackFeatures.cpp
TrackList.cpp
)
target_link_libraries(test-database PRIVATE
src/libs/services/database/test/Cluster.cpp
+185 -186
View File
@@ -24,60 +24,73 @@
using namespace Database;
TEST_F(DatabaseFixture, SingleCluster)
TEST_F(DatabaseFixture, Cluster)
{
{
auto transaction {session.createUniqueTransaction()};
EXPECT_EQ(Cluster::getCount(session), 0);
EXPECT_EQ(ClusterType::getCount(session), 0);
}
ScopedClusterType clusterType {session, "MyType"};
{
auto transaction {session.createUniqueTransaction()};
EXPECT_EQ(ClusterType::getCount(session), 1);
}
{
ScopedCluster cluster {session, clusterType.lockAndGet(), "MyCluster"};
{
auto transaction {session.createUniqueTransaction()};
auto clusters {Cluster::getAll(session)};
ASSERT_EQ(clusters.size(), 1);
EXPECT_EQ(clusters.front()->getId(), cluster.getId());
EXPECT_EQ(clusters.front()->getType()->getId(), clusterType.getId());
EXPECT_EQ(Cluster::getCount(session), 1);
EXPECT_EQ(cluster->getType()->getId(), clusterType.getId());
clusters = Cluster::getAllOrphans(session);
ASSERT_EQ(clusters.size(), 1);
EXPECT_EQ(clusters.front()->getId(), cluster.getId());
auto clusters {Cluster::find(session, Range {})};
ASSERT_EQ(clusters.results.size(), 1);
EXPECT_EQ(clusters.results.front(), cluster.getId());
auto clusterTypes {ClusterType::getAll(session)};
ASSERT_EQ(clusterTypes.size(), 1);
EXPECT_EQ(clusterTypes.front()->getId(), clusterType.getId());
clusters = Cluster::findOrphans(session, Range {});
ASSERT_EQ(clusters.results.size(), 1);
EXPECT_EQ(clusters.results.front(), cluster.getId());
clusterTypes = ClusterType::getAllUsed(session);
ASSERT_EQ(clusterTypes.size(), 1);
EXPECT_EQ(clusterTypes.front()->getId(), clusterType.getId());
auto clusterTypes {ClusterType::find(session, Range {})};
ASSERT_EQ(clusterTypes.results.size(), 1);
EXPECT_EQ(clusterTypes.results.front(), clusterType.getId());
clusterTypes = ClusterType::getAllOrphans(session);
EXPECT_TRUE(clusterTypes.empty());
clusterTypes = ClusterType::findUsed(session, Range {});
ASSERT_EQ(clusterTypes.results.size(), 1);
EXPECT_EQ(clusterTypes.results.front(), clusterType.getId());
clusterTypes = ClusterType::findOrphans(session, Range {});
EXPECT_TRUE(clusterTypes.results.empty());
}
}
{
auto transaction {session.createUniqueTransaction()};
auto clusterTypes {ClusterType::getAllOrphans(session)};
ASSERT_EQ(clusterTypes.size(), 1);
EXPECT_EQ(clusterTypes.front()->getId(), clusterType.getId());
auto clusterTypes {ClusterType::findOrphans(session, Range {})};
ASSERT_EQ(clusterTypes.results.size(), 1);
EXPECT_EQ(clusterTypes.results.front(), clusterType.getId());
ASSERT_TRUE(ClusterType::getAllUsed(session).empty());
ASSERT_TRUE(ClusterType::findUsed(session, Range {}).results.empty());
}
}
TEST_F(DatabaseFixture, SingleTrackSingleCluster)
TEST_F(DatabaseFixture, Cluster_singleTrack)
{
ScopedTrack track {session, "MyTrack"};
ScopedClusterType clusterType {session, "MyClusterType"};
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Cluster::getAllOrphans(session).empty());
auto clusterTypes {ClusterType::getAllOrphans(session)};
ASSERT_EQ(clusterTypes.size(), 1);
EXPECT_EQ(clusterTypes.front()->getId(), clusterType.getId());
EXPECT_TRUE(Cluster::findOrphans(session, Range {}).results.empty());
auto clusterTypes {ClusterType::findOrphans(session, Range {})};
ASSERT_EQ(clusterTypes.results.size(), 1);
EXPECT_EQ(clusterTypes.results.front(), clusterType.getId());
}
ScopedCluster cluster1 {session, clusterType.lockAndGet(), "MyCluster1"};
@@ -85,17 +98,12 @@ TEST_F(DatabaseFixture, SingleTrackSingleCluster)
{
auto transaction {session.createSharedTransaction()};
auto clusters {Cluster::getAllOrphans(session)};
EXPECT_EQ(clusters.size(), 2);
auto clusters {Cluster::findOrphans(session, Range {})};
EXPECT_EQ(clusters.results.size(), 2);
EXPECT_TRUE(track->getClusters().empty());
EXPECT_TRUE(track->getClusterIds().empty());
}
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Track::getAllIdsWithClusters(session).empty());
}
{
auto transaction {session.createUniqueTransaction()};
@@ -104,29 +112,22 @@ TEST_F(DatabaseFixture, SingleTrackSingleCluster)
{
auto transaction {session.createSharedTransaction()};
auto tracks {Track::getAllIdsWithClusters(session)};
ASSERT_EQ(tracks.size(), 1);
EXPECT_EQ(tracks.front(), track.getId());
}
auto clusters {Cluster::findOrphans(session, Range {})};
ASSERT_EQ(clusters.results.size(), 1);
EXPECT_EQ(clusters.results.front(), cluster2.getId());
{
auto transaction {session.createSharedTransaction()};
auto clusters {Cluster::getAllOrphans(session)};
ASSERT_EQ(clusters.size(), 1);
EXPECT_EQ(clusters.front()->getId(), cluster2.getId());
EXPECT_TRUE(ClusterType::getAllOrphans(session).empty());
EXPECT_TRUE(ClusterType::findOrphans(session, Range {}).results.empty());
}
{
auto transaction {session.createSharedTransaction()};
auto tracks {Track::getByClusters(session, {cluster1.getId()})};
ASSERT_EQ(tracks.size(), 1);
EXPECT_EQ(tracks.front()->getId(), track.getId());
auto tracks {Track::find(session, Track::FindParameters {}.setClusters({cluster1.getId()}))};
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
tracks = Track::getByClusters(session, {cluster2.getId()});
EXPECT_TRUE(tracks.empty());
tracks = Track::find(session, Track::FindParameters {}.setClusters({cluster2.getId()}));
EXPECT_TRUE(tracks.results.empty());
}
{
@@ -142,7 +143,7 @@ TEST_F(DatabaseFixture, SingleTrackSingleCluster)
}
}
TEST_F(DatabaseFixture, MultipleTracksSingleCluster)
TEST_F(DatabaseFixture, Cluster_multiTracks)
{
std::list<ScopedTrack> tracks;
ScopedClusterType clusterType {session, "MyClusterType"};
@@ -160,19 +161,19 @@ TEST_F(DatabaseFixture, MultipleTracksSingleCluster)
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Cluster::getAllOrphans(session).empty());
EXPECT_TRUE(Cluster::findOrphans(session, Range {}).results.empty());
EXPECT_EQ(cluster->getTracksCount(), tracks.size());
for (auto trackCluster : cluster->getTracks())
for (TrackId trackId : cluster->getTracks(Range {}).results)
{
auto it {std::find_if(std::cbegin(tracks), std::cend(tracks), [&](const ScopedTrack& track) { return trackCluster->getId() == track.getId(); })};
auto it {std::find_if(std::cbegin(tracks), std::cend(tracks), [&](const ScopedTrack& track) { return trackId == track.getId(); })};
EXPECT_TRUE(it != std::cend(tracks));
}
}
}
TEST_F(DatabaseFixture, MultipleTracksMultipleClustersTopRelease)
TEST_F(DatabaseFixture, Cluster_multiTracksMultipleClustersTopRelease)
{
ScopedClusterType clusterType {session, "ClusterType"};
ScopedCluster cluster1 {session, clusterType.lockAndGet(), "Cluster1"};
@@ -268,16 +269,25 @@ TEST_F(DatabaseFixture, MultipleTracksMultipleClustersTopRelease)
}
}
TEST_F(DatabaseFixture,SingleTrackSingleReleaseSingleCluster)
TEST_F(DatabaseFixture, Cluster_singleTrackSingleReleaseSingleCluster)
{
ScopedTrack track {session, "MyTrackFile"};
ScopedRelease release {session, "MyRelease"};
ScopedClusterType clusterType {session, "MyClusterType"};
ScopedCluster cluster {session, clusterType .lockAndGet(), "MyCluster"};
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Release::getAllIdsWithClusters(session).empty());
EXPECT_TRUE(Cluster::findOrphans(session, Range {}).results.empty());
}
ScopedClusterType clusterType {session, "MyClusterType"};
ScopedCluster cluster {session, clusterType.lockAndGet(), "MyCluster"};
ScopedCluster unusedCluster {session, clusterType.lockAndGet(), "MyClusterUnused"};
{
auto transaction {session.createSharedTransaction()};
ASSERT_EQ(Cluster::findOrphans(session, Range {}).results.size(), 2);
EXPECT_TRUE(Release::find(session, Release::FindParameters {}.setClusters({unusedCluster.getId()})).results.empty());
EXPECT_EQ(Release::find(session, Release::FindParameters {}).results.size(), 1);
}
{
@@ -289,24 +299,27 @@ TEST_F(DatabaseFixture,SingleTrackSingleReleaseSingleCluster)
{
auto transaction {session.createSharedTransaction()};
auto releases {Release::getAllIdsWithClusters(session)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front(), release.getId());
{
auto clusters {Cluster::findOrphans(session, Range {})};
ASSERT_EQ(clusters.results.size(), 1);
EXPECT_EQ(clusters.results.front(), unusedCluster.getId());
}
}
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Cluster::getAllOrphans(session).empty());
EXPECT_TRUE(Release::getAllOrphans(session).empty());
auto releases {Release::find(session, Release::FindParameters {}.setClusters({cluster.getId()}))};
ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId());
}
{
auto transaction {session.createSharedTransaction()};
auto releases {Release::getByClusters(session, {cluster.getId()})};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release.getId());
auto releases {Release::find(session, Release::FindParameters {}.setClusters({unusedCluster.getId()}))};
EXPECT_EQ(releases.results.size(), 0);
}
{
@@ -314,6 +327,8 @@ TEST_F(DatabaseFixture,SingleTrackSingleReleaseSingleCluster)
EXPECT_EQ(cluster->getReleasesCount(), 1);
EXPECT_EQ(cluster->getTracksCount(), 1);
EXPECT_EQ(unusedCluster->getReleasesCount(), 0);
EXPECT_EQ(unusedCluster->getTracksCount(), 0);
}
}
@@ -334,10 +349,10 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiClusters)
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(ClusterType::getAllOrphans(session).empty());
EXPECT_EQ(Cluster::getAllOrphans(session).size(), 2);
EXPECT_TRUE(Release::getAllOrphans(session).empty());
EXPECT_TRUE(Artist::getAllOrphans(session).empty());
EXPECT_TRUE(ClusterType::findOrphans(session, Range {}).results.empty());
EXPECT_EQ(Cluster::findOrphans(session, Range {}).results.size(), 2);
EXPECT_TRUE(Release::findOrphans(session, Range {}).results.empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
}
{
@@ -349,12 +364,12 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiClusters)
{
auto transaction {session.createSharedTransaction()};
auto artists {Artist::getByClusters(session, {cluster1.getId()}, Artist::SortMethod::ByName)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
auto artists {Artist::find(session, Artist::FindParameters {}.setClusters({cluster1.getId()}))};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
EXPECT_TRUE(Artist::getByClusters(session, {cluster2.getId()}, Artist::SortMethod::ByName).empty());
EXPECT_TRUE(Artist::getByClusters(session, {cluster3.getId()}, Artist::SortMethod::ByName).empty());
EXPECT_TRUE(Artist::find(session, Artist::FindParameters {}.setClusters({cluster2.getId()})).results.empty());
EXPECT_TRUE(Artist::find(session, Artist::FindParameters {}.setClusters({cluster3.getId()})).results.empty());
cluster2.get().modify()->addTrack(track.get());
}
@@ -362,19 +377,19 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiClusters)
{
auto transaction {session.createSharedTransaction()};
auto artists {Artist::getByClusters(session, {cluster1.getId()}, Artist::SortMethod::ByName)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
auto artists {Artist::find(session, Artist::FindParameters {}.setClusters({cluster1.getId()}))};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
artists = Artist::getByClusters(session, {cluster2.getId()}, Artist::SortMethod::ByName);
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
artists = Artist::find(session, Artist::FindParameters {}.setClusters({cluster2.getId()}));
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
artists = Artist::getByClusters(session, {cluster1.getId(), cluster2.getId()}, Artist::SortMethod::ByName);
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
artists = Artist::find(session, Artist::FindParameters {}.setClusters({cluster1.getId()}));
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
EXPECT_TRUE(Artist::getByClusters(session, {cluster3.getId()}, Artist::SortMethod::ByName).empty());
EXPECT_TRUE(Artist::find(session, Artist::FindParameters {}.setClusters({cluster3.getId()})).results.empty());
}
}
@@ -395,17 +410,17 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiRolesMultiClusters)
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Cluster::getAllOrphans(session).empty());
EXPECT_TRUE(Release::getAllOrphans(session).empty());
EXPECT_TRUE(Artist::getAllOrphans(session).empty());
EXPECT_TRUE(Cluster::findOrphans(session, Range {}).results.empty());
EXPECT_TRUE(Release::findOrphans(session, Range {}).results.empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Artist::getByClusters(session, {cluster.getId()}, Artist::SortMethod::ByName)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
auto artists {Artist::find(session, Artist::FindParameters {}.setClusters({cluster.getId()}))};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
}
}
@@ -435,8 +450,8 @@ TEST_F(DatabaseFixture, MultiTracksSingleArtistMultiClusters)
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Cluster::getAllOrphans(session).empty());
EXPECT_TRUE(Artist::getAllOrphans(session).empty());
EXPECT_TRUE(Cluster::findOrphans(session, Range {}).results.empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
}
{
@@ -445,9 +460,9 @@ TEST_F(DatabaseFixture, MultiTracksSingleArtistMultiClusters)
std::vector<ClusterId> clusterIds;
std::transform(std::cbegin(clusters), std::cend(clusters), std::back_inserter(clusterIds), [](const ScopedCluster& cluster) { return cluster.getId(); });
auto artists {Artist::getByClusters(session, clusterIds, Artist::SortMethod::ByName)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
auto artists {Artist::find(session, Artist::FindParameters {}.setClusters(clusterIds))};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
}
}
@@ -471,15 +486,11 @@ TEST_F(DatabaseFixture, MultipleTracksSingleClusterSimilarity)
{
auto transaction {session.createSharedTransaction()};
const auto similarTracks {Track::getSimilarTracks(session, {tracks.front().getId()})};
EXPECT_EQ(similarTracks.size(), tracks.size() - 1);
for (auto similarTrack : similarTracks)
const auto similarTracks {Track::findSimilarTracks(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 ScopedTrack& track)
{
return similarTrack->getId() == track.getId();
}) != std::cend(tracks));
EXPECT_TRUE(std::find_if(std::next(std::cbegin(tracks), 1), std::cend(tracks), [&](const auto& track) { return similarTrackId == track.getId(); }) != std::cend(tracks));
}
}
}
@@ -516,17 +527,17 @@ TEST_F(DatabaseFixture, MultipleTracksMultipleClustersSimilarity)
auto transaction {session.createSharedTransaction()};
{
auto similarTracks {Track::getSimilarTracks(session, {tracks.back().getId()}, 0, 4)};
EXPECT_EQ(similarTracks.size(), 4);
for (auto similarTrack : similarTracks)
EXPECT_TRUE(std::find_if(std::next(std::cbegin(tracks), 5), std::next(std::cend(tracks), -1), [&](const ScopedTrack& track) { return similarTrack->getId() == track.getId(); }) != std::cend(tracks));
auto similarTracks {Track::findSimilarTracks(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::getSimilarTracks(session, {tracks.front().getId()})};
EXPECT_EQ(similarTracks.size(), tracks.size() - 1);
for (auto similarTrack : similarTracks)
EXPECT_TRUE(std::find_if(std::next(std::cbegin(tracks), 1), std::cend(tracks), [&](const ScopedTrack& track) { return similarTrack->getId() == track.getId(); }) != std::cend(tracks));
auto similarTracks {Track::findSimilarTracks(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));
}
}
}
@@ -539,11 +550,6 @@ TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtistSingleCluster)
ScopedClusterType clusterType {session, "MyType"};
ScopedCluster cluster {session, clusterType.lockAndGet(), "MyCluster"};
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Artist::getAllIdsWithClusters(session).empty());
}
{
auto transaction {session.createUniqueTransaction()};
@@ -555,25 +561,18 @@ TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtistSingleCluster)
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Cluster::getAllOrphans(session).empty());
EXPECT_TRUE(ClusterType::getAllOrphans(session).empty());
EXPECT_TRUE(Artist::getAllOrphans(session).empty());
EXPECT_TRUE(Release::getAllOrphans(session).empty());
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Artist::getAllIdsWithClusters(session)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front(), artist.getId());
EXPECT_TRUE(Cluster::findOrphans(session, Range {}).results.empty());
EXPECT_TRUE(ClusterType::findOrphans(session, Range {}).results.empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
EXPECT_TRUE(Release::findOrphans(session, Range {}).results.empty());
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Artist::getByClusters(session, {cluster.getId()}, Artist::SortMethod::ByName)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist.getId());
auto artists {Artist::find(session, Artist::FindParameters {}.setClusters({cluster.getId()}))};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId());
auto releases {artist->getReleases()};
ASSERT_EQ(releases.size(), 1);
@@ -735,9 +734,9 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
EXPECT_TRUE(trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getReleasesReverse({}, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getTracksReverse({}, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getArtistsOrderedByRecentFirst({}, std::nullopt, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getReleasesOrderedByRecentFirst({}, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getTracksOrderedByRecentFirst({}, std::nullopt, moreResults).empty());
}
{
@@ -750,15 +749,15 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults)};
const auto artists {trackList->getArtistsOrderedByRecentFirst({}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
const auto releases {trackList->getReleasesReverse({}, std::nullopt, moreResults)};
const auto releases {trackList->getReleasesOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size() , 1);
EXPECT_EQ(releases.front()->getId(), release1.getId());
const auto tracks {trackList->getTracksReverse({}, std::nullopt, moreResults)};
const auto tracks {trackList->getTracksOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 1);
EXPECT_EQ(tracks.front()->getId(), track1.getId());
}
@@ -767,15 +766,15 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({cluster1.getId()}, std::nullopt, std::nullopt, moreResults)};
const auto artists {trackList->getArtistsOrderedByRecentFirst({cluster1.getId()}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
const auto releases {trackList->getReleasesReverse({cluster1.getId()}, std::nullopt, moreResults)};
const auto releases {trackList->getReleasesOrderedByRecentFirst({cluster1.getId()}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release1.getId());
const auto tracks {trackList->getTracksReverse({cluster1.getId()}, std::nullopt, moreResults)};
const auto tracks {trackList->getTracksOrderedByRecentFirst({cluster1.getId()}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 1);
EXPECT_EQ(tracks.front()->getId(), track1.getId());
}
@@ -784,15 +783,15 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({cluster3.getId()}, std::nullopt, std::nullopt, moreResults)};
const auto artists {trackList->getArtistsOrderedByRecentFirst({cluster3.getId()}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
const auto releases {trackList->getReleasesReverse({cluster3.getId()}, std::nullopt, moreResults)};
const auto releases {trackList->getReleasesOrderedByRecentFirst({cluster3.getId()}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release1.getId());
const auto tracks {trackList->getTracksReverse({cluster3.getId()}, std::nullopt, moreResults)};
const auto tracks {trackList->getTracksOrderedByRecentFirst({cluster3.getId()}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 1);
EXPECT_EQ(tracks.front()->getId(), track1.getId());
}
@@ -801,7 +800,7 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({cluster1.getId()}, TrackArtistLinkType::Artist, std::nullopt, moreResults)};
const auto artists {trackList->getArtistsOrderedByRecentFirst({cluster1.getId()}, TrackArtistLinkType::Artist, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
}
@@ -810,7 +809,7 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({}, TrackArtistLinkType::Artist, std::nullopt, moreResults)};
const auto artists {trackList->getArtistsOrderedByRecentFirst({}, TrackArtistLinkType::Artist, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
}
@@ -819,11 +818,11 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
EXPECT_TRUE(trackList->getArtistsReverse({cluster2.getId()}, std::nullopt, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getReleasesReverse({cluster2.getId()}, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getTracksReverse({cluster2.getId()}, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getArtistsOrderedByRecentFirst({cluster2.getId()}, std::nullopt, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getReleasesOrderedByRecentFirst({cluster2.getId()}, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getTracksOrderedByRecentFirst({cluster2.getId()}, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getArtistsReverse({}, TrackArtistLinkType::ReleaseArtist, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getArtistsOrderedByRecentFirst({}, TrackArtistLinkType::ReleaseArtist, std::nullopt, moreResults).empty());
}
{
@@ -836,17 +835,17 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults)};
const auto artists {trackList->getArtistsOrderedByRecentFirst({}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists[0]->getId(), artist2.getId());
EXPECT_EQ(artists[1]->getId(), artist1.getId());
const auto releases {trackList->getReleasesReverse({}, std::nullopt, moreResults)};
const auto releases {trackList->getReleasesOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 2);
EXPECT_EQ(releases[0]->getId(), release2.getId());
EXPECT_EQ(releases[1]->getId(), release1.getId());
const auto tracks {trackList->getTracksReverse({}, std::nullopt, moreResults)};
const auto tracks {trackList->getTracksOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 2);
EXPECT_EQ(tracks[0]->getId(), track2.getId());
EXPECT_EQ(tracks[1]->getId(),track1.getId());
@@ -856,17 +855,17 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({cluster3.getId()}, std::nullopt, std::nullopt, moreResults)};
const auto artists {trackList->getArtistsOrderedByRecentFirst({cluster3.getId()}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists[0]->getId(), artist2.getId());
EXPECT_EQ(artists[1]->getId(), artist1.getId());
const auto releases {trackList->getReleasesReverse({cluster3.getId()}, std::nullopt, moreResults)};
const auto releases {trackList->getReleasesOrderedByRecentFirst({cluster3.getId()}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 2);
EXPECT_EQ(releases[0]->getId(), release2.getId());
EXPECT_EQ(releases[1]->getId(), release1.getId());
const auto tracks {trackList->getTracksReverse({cluster3.getId()}, std::nullopt, moreResults)};
const auto tracks {trackList->getTracksOrderedByRecentFirst({cluster3.getId()}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 2);
EXPECT_EQ(tracks[0]->getId(), track2.getId());
EXPECT_EQ(tracks[1]->getId(), track1.getId());
@@ -876,15 +875,15 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({cluster1.getId()}, std::nullopt, std::nullopt, moreResults)};
const auto artists {trackList->getArtistsOrderedByRecentFirst({cluster1.getId()}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
const auto releases {trackList->getReleasesReverse({cluster1.getId()}, std::nullopt, moreResults)};
const auto releases {trackList->getReleasesOrderedByRecentFirst({cluster1.getId()}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release1.getId());
const auto tracks {trackList->getTracksReverse({cluster1.getId()}, std::nullopt, moreResults)};
const auto tracks {trackList->getTracksOrderedByRecentFirst({cluster1.getId()}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 1);
EXPECT_EQ(tracks.front()->getId(), track1.getId());
}
@@ -893,15 +892,15 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({cluster2.getId()}, std::nullopt, std::nullopt, moreResults)};
const auto artists {trackList->getArtistsOrderedByRecentFirst({cluster2.getId()}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist2.getId());
const auto releases {trackList->getReleasesReverse({cluster2.getId()}, std::nullopt, moreResults)};
const auto releases {trackList->getReleasesOrderedByRecentFirst({cluster2.getId()}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release2.getId());
const auto tracks {trackList->getTracksReverse({cluster2.getId()}, std::nullopt, moreResults)};
const auto tracks {trackList->getTracksOrderedByRecentFirst({cluster2.getId()}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 1);
EXPECT_EQ(tracks.front()->getId(), track2.getId());
}
@@ -916,17 +915,17 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults)};
const auto artists {trackList->getArtistsOrderedByRecentFirst({}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists[0]->getId(), artist1.getId());
EXPECT_EQ(artists[1]->getId(), artist2.getId());
const auto releases {trackList->getReleasesReverse({}, std::nullopt, moreResults)};
const auto releases {trackList->getReleasesOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 2);
EXPECT_EQ(releases[0]->getId(), release1.getId());
EXPECT_EQ(releases[1]->getId(), release2.getId());
const auto tracks {trackList->getTracksReverse({}, std::nullopt, moreResults)};
const auto tracks {trackList->getTracksOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 2);
EXPECT_EQ(tracks[0]->getId(), track1.getId());
EXPECT_EQ(tracks[1]->getId(), track2.getId());
@@ -936,17 +935,17 @@ TEST_F(DatabaseFixture, SingleTrackListMultipleTrackMultiClustersRecentlyPlayed)
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({cluster3.getId()}, std::nullopt, std::nullopt, moreResults)};
const auto artists {trackList->getArtistsOrderedByRecentFirst({cluster3.getId()}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists[0]->getId(), artist1.getId());
EXPECT_EQ(artists[1]->getId(), artist2.getId());
const auto releases {trackList->getReleasesReverse({cluster3.getId()}, std::nullopt, moreResults)};
const auto releases {trackList->getReleasesOrderedByRecentFirst({cluster3.getId()}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 2);
EXPECT_EQ(releases[0]->getId(), release1.getId());
EXPECT_EQ(releases[1]->getId(), release2.getId());
const auto tracks {trackList->getTracksReverse({cluster3.getId()}, std::nullopt, moreResults)};
const auto tracks {trackList->getTracksOrderedByRecentFirst({cluster3.getId()}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 2);
EXPECT_EQ(tracks[0]->getId(), track1.getId());
EXPECT_EQ(tracks[1]->getId(), track2.getId());
@@ -964,9 +963,9 @@ TEST_F(DatabaseFixture, MultipleTracksMultipleArtistsMultiClusters)
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(artist1->getSimilarArtists().empty());
EXPECT_TRUE(artist2->getSimilarArtists().empty());
EXPECT_TRUE(artist3->getSimilarArtists().empty());
EXPECT_TRUE(artist1->findSimilarArtists().results.empty());
EXPECT_TRUE(artist2->findSimilarArtists().results.empty());
EXPECT_TRUE(artist3->findSimilarArtists().results.empty());
}
std::list<ScopedTrack> tracks;
@@ -998,38 +997,38 @@ TEST_F(DatabaseFixture, MultipleTracksMultipleArtistsMultiClusters)
auto transaction {session.createSharedTransaction()};
{
auto artists {artist1->getSimilarArtists()};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist2.getId());
auto artists {artist1->findSimilarArtists()};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist2.getId());
}
{
auto artists {artist1->getSimilarArtists({TrackArtistLinkType::Artist})};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist2.getId());
auto artists {artist1->findSimilarArtists({TrackArtistLinkType::Artist})};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist2.getId());
}
{
auto artists {artist1->getSimilarArtists({TrackArtistLinkType::ReleaseArtist})};
EXPECT_EQ(artists.empty(), 1);
auto artists {artist1->findSimilarArtists({TrackArtistLinkType::ReleaseArtist})};
EXPECT_EQ(artists.results.empty(), 1);
}
{
auto artists {artist1->getSimilarArtists({TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist})};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist2.getId());
auto artists {artist1->findSimilarArtists({TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist})};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist2.getId());
}
{
auto artists {artist1->getSimilarArtists({TrackArtistLinkType::Composer})};
EXPECT_TRUE(artists.empty());
auto artists {artist1->findSimilarArtists({TrackArtistLinkType::Composer})};
EXPECT_TRUE(artists.results.empty());
}
{
auto artists {artist2->getSimilarArtists()};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists[0]->getId(), artist1.getId());
EXPECT_EQ(artists[1]->getId(), artist3.getId());
auto artists {artist2->findSimilarArtists()};
ASSERT_EQ(artists.results.size(), 2);
EXPECT_EQ(artists.results[0], artist1.getId());
EXPECT_EQ(artists.results[1], artist3.getId());
}
}
}
src/libs/services/database/test/Common.cpp
+211
View File
@@ -0,0 +1,211 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Common.hpp"
#include "services/database/Artist.hpp"
#include "services/database/Cluster.hpp"
#include "services/database/Db.hpp"
#include "services/database/Listen.hpp"
#include "services/database/Release.hpp"
#include "services/database/Session.hpp"
#include "services/database/StarredArtist.hpp"
#include "services/database/StarredRelease.hpp"
#include "services/database/StarredTrack.hpp"
#include "services/database/Track.hpp"
#include "services/database/TrackArtistLink.hpp"
#include "services/database/TrackBookmark.hpp"
#include "services/database/TrackList.hpp"
#include "services/database/Types.hpp"
#include "services/database/User.hpp"
TmpDatabase::TmpDatabase()
: _tmpFile {std::tmpnam(nullptr)}
, _fileDeleter {_tmpFile}
, _db {_tmpFile}
{
}
Database::Db&
TmpDatabase::getDb()
{
return _db;
}
DatabaseFixture::~DatabaseFixture()
{
testDatabaseEmpty();
}
void
DatabaseFixture::SetUpTestCase()
{
_tmpDb = std::make_unique<TmpDatabase>();
{
Database::Session s {_tmpDb->getDb()};
s.prepareTables();
s.optimize();
// remove default created entries
{
auto transaction {s.createUniqueTransaction()};
auto clusterTypes {Database::ClusterType::find(s, Database::Range {})};
for (auto clusterTypeId : clusterTypes.results)
{
auto clusterType {Database::ClusterType::find(s, clusterTypeId)};
clusterType.remove();
}
}
}
}
void
DatabaseFixture::TearDownTestCase()
{
_tmpDb.reset();
}
void
DatabaseFixture::testDatabaseEmpty()
{
using namespace Database;
auto uniqueTransaction {session.createUniqueTransaction()};
EXPECT_EQ(Artist::getCount(session), 0);
EXPECT_EQ(Cluster::getCount(session), 0);
EXPECT_EQ(ClusterType::getCount(session), 0);
EXPECT_EQ(Listen::getCount(session), 0);
EXPECT_EQ(Release::getCount(session), 0);
EXPECT_EQ(StarredArtist::getCount(session), 0);
EXPECT_EQ(StarredRelease::getCount(session), 0);
EXPECT_EQ(StarredTrack::getCount(session), 0);
EXPECT_EQ(Track::getCount(session), 0);
EXPECT_EQ(TrackBookmark::getCount(session), 0);
EXPECT_EQ(TrackList::getCount(session), 0);
EXPECT_EQ(User::getCount(session), 0);
}
TEST_F(DatabaseFixture, Common_subRangeEmpty)
{
using namespace Database;
RangeResults<int> results;
results.range = Range {0, 0};
results.results = {};
results.moreResults = false;
{
auto subRange {results.getSubRange(Range {0, 0})};
EXPECT_FALSE(subRange.moreResults);
ASSERT_EQ(subRange.results.size(), 0);
EXPECT_EQ(subRange.range, Range {});
}
{
auto subRange {results.getSubRange(Range {0, 1})};
EXPECT_FALSE(subRange.moreResults);
ASSERT_EQ(subRange.results.size(), 0);
}
}
TEST_F(DatabaseFixture, Common_IdType)
{
using namespace Database;
{
const IdType id{};
EXPECT_FALSE(id.isValid());
}
{
const IdType id{0};
EXPECT_TRUE(id.isValid());
}
{
const IdType id1{0};
const IdType id2{0};
EXPECT_EQ(id1, id2);
}
{
const IdType id1{0};
const IdType id2{1};
EXPECT_NE(id1, id2);
EXPECT_LT(id1, id2);
EXPECT_GT(id2, id1);
}
}
TEST_F(DatabaseFixture, Common_subRange)
{
using namespace Database;
RangeResults<int> results;
results.range = Range {0, 2};
results.results = {5, 6};
results.moreResults = false;
{
auto subRange {results.getSubRange(Range {0, 1})};
EXPECT_TRUE(subRange.moreResults);
ASSERT_EQ(subRange.results.size(), 1);
EXPECT_EQ(subRange.results.front(), 5);
}
{
auto subRange {results.getSubRange(Range {1, 1})};
EXPECT_FALSE(subRange.moreResults);
ASSERT_EQ(subRange.results.size(), 1);
EXPECT_EQ(subRange.results.front(), 6);
}
{
auto subRange {results.getSubRange(Range {0, 2})};
EXPECT_FALSE(subRange.moreResults);
ASSERT_EQ(subRange.results.size(), 2);
EXPECT_EQ(subRange.results.front(), 5);
EXPECT_EQ(subRange.results.back(), 6);
}
{
auto subRange {results.getSubRange(Range {})};
EXPECT_FALSE(subRange.moreResults);
ASSERT_EQ(subRange.results.size(), 2);
EXPECT_EQ(subRange.results.front(), 5);
EXPECT_EQ(subRange.results.back(), 6);
EXPECT_EQ(subRange.range, results.range);
}
{
auto subRange {results.getSubRange(Range {1, 0})};
EXPECT_FALSE(subRange.moreResults);
ASSERT_EQ(subRange.results.size(), 1);
EXPECT_EQ(subRange.results.front(), 6);
const Range expectedRange {1, 1};
EXPECT_EQ(subRange.range, expectedRange);
}
{
auto subRange {results.getSubRange(Range {3, 2})};
EXPECT_FALSE(subRange.moreResults);
ASSERT_EQ(subRange.results.size(), 0);
const Range expectedRange {2, 0};
EXPECT_EQ(subRange.range, expectedRange);
}
}
src/libs/services/database/test/Common.hpp
+14 -46
View File
@@ -27,11 +27,13 @@
#include "services/database/Artist.hpp"
#include "services/database/Cluster.hpp"
#include "services/database/Db.hpp"
#include "services/database/Listen.hpp"
#include "services/database/Release.hpp"
#include "services/database/Session.hpp"
#include "services/database/Track.hpp"
#include "services/database/TrackArtistLink.hpp"
#include "services/database/TrackBookmark.hpp"
#include "services/database/TrackFeatures.hpp"
#include "services/database/TrackList.hpp"
#include "services/database/Types.hpp"
#include "services/database/User.hpp"
@@ -57,7 +59,7 @@ class ScopedEntity
{
auto transaction {_session.createUniqueTransaction()};
auto entity {T::getById(_session, _id)};
auto entity {T::find(_session, _id)};
entity.remove();
}
@@ -76,7 +78,7 @@ class ScopedEntity
{
_session.checkSharedLocked();
auto entity {T::getById(_session, _id)};
auto entity {T::find(_session, _id)};
EXPECT_TRUE(entity);
return entity;
}
@@ -98,7 +100,6 @@ using ScopedCluster = ScopedEntity<Database::Cluster>;
using ScopedClusterType = ScopedEntity<Database::ClusterType>;
using ScopedRelease = ScopedEntity<Database::Release>;
using ScopedTrack = ScopedEntity<Database::Track>;
using ScopedTrackBookmark = ScopedEntity<Database::TrackBookmark>;
using ScopedTrackList = ScopedEntity<Database::TrackList>;
using ScopedUser = ScopedEntity<Database::User>;
@@ -120,60 +121,27 @@ class ScopedFileDeleter final
class TmpDatabase final
{
public:
Database::Db& getDb() { return _db; }
TmpDatabase ();
Database::Db& getDb();
private:
const std::filesystem::path _tmpFile {std::tmpnam(nullptr)};
ScopedFileDeleter fileDeleter {_tmpFile};
Database::Db _db {_tmpFile};
const std::filesystem::path _tmpFile;
ScopedFileDeleter _fileDeleter;
Database::Db _db;
};
class DatabaseFixture : public ::testing::Test
{
public:
~DatabaseFixture()
{
testDatabaseEmpty();
}
~DatabaseFixture();
public:
static void SetUpTestCase()
{
_tmpDb = std::make_unique<TmpDatabase>();
{
Database::Session s {_tmpDb->getDb()};
s.prepareTables();
s.optimize();
// remove default created entries
{
auto transaction {s.createUniqueTransaction()};
auto clusterTypes {Database::ClusterType::getAll(s)};
for (auto& clusterType : clusterTypes)
clusterType.remove();
}
}
}
static void TearDownTestCase()
{
_tmpDb.reset();
}
static void SetUpTestCase();
static void TearDownTestCase();
private:
void testDatabaseEmpty()
{
auto uniqueTransaction {session.createUniqueTransaction()};
EXPECT_TRUE(Database::Artist::getAll(session, Database::Artist::SortMethod::ByName).empty());
EXPECT_TRUE(Database::Cluster::getAll(session).empty());
EXPECT_TRUE(Database::ClusterType::getAll(session).empty());
EXPECT_TRUE(Database::Release::getAll(session).empty());
EXPECT_TRUE(Database::Track::getAll(session).empty());
EXPECT_TRUE(Database::TrackBookmark::getAll(session).empty());
EXPECT_TRUE(Database::TrackList::getAll(session).empty());
EXPECT_TRUE(Database::User::getAll(session).empty());
}
void testDatabaseEmpty();
static inline std::unique_ptr<TmpDatabase> _tmpDb {};
src/libs/services/database/test/DatabaseTest.cpp
+6 -212
View File
@@ -42,8 +42,8 @@ TEST_F(DatabaseFixture, MultiTracksSingleArtistSingleRelease)
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Release::getAllOrphans(session).empty());
EXPECT_TRUE(Artist::getAllOrphans(session).empty());
EXPECT_TRUE(Release::findOrphans(session, Range {}).results.empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
}
{
@@ -89,8 +89,8 @@ TEST_F(DatabaseFixture, SingleUser)
{
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(User::getAll(session).empty());
EXPECT_TRUE(User::getAllIds(session).empty());
EXPECT_TRUE(User::find(session, Range {}).results.empty());
EXPECT_EQ(User::getCount(session), 0);
}
ScopedUser user {session, "MyUser"};
@@ -98,214 +98,8 @@ TEST_F(DatabaseFixture, SingleUser)
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(user->getQueuedTrackList(session)->getCount(), 0);
EXPECT_EQ(User::getAll(session).size(), 1);
EXPECT_EQ(User::getAllIds(session).size(), 1);
}
}
TEST_F(DatabaseFixture, SingleTrackList)
{
ScopedUser user {session, "MyUser"};
ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
{
auto transaction {session.createSharedTransaction()};
auto trackLists {TrackList::getAll(session, user.get(), TrackList::Type::Playlist)};
ASSERT_EQ(trackLists.size(), 1);
EXPECT_EQ(trackLists.front()->getId(), trackList.getId());
}
}
TEST_F(DatabaseFixture, SingleTrackListMultipleTrack)
{
ScopedUser user {session, "MyUser"};
ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
std::list<ScopedTrack> tracks;
for (std::size_t i {}; i < 10; ++i)
{
tracks.emplace_back(session, "MyTrack" + std::to_string(i));
auto transaction {session.createUniqueTransaction()};
TrackListEntry::create(session, tracks.back().get(), trackList.get());
}
{
auto transaction {session.createSharedTransaction()};
ASSERT_EQ(trackList->getCount(), tracks.size());
const auto trackIds {trackList->getTrackIds()};
for (auto trackId : trackIds)
EXPECT_TRUE(std::any_of(std::cbegin(tracks), std::cend(tracks), [trackId](const ScopedTrack& track) { return track.getId() == trackId; }));
}
}
TEST_F(DatabaseFixture, SingleTrackListMultipleTrackDateTime)
{
ScopedUser user {session, "MyUser"};
ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
ScopedTrack track1 {session, "MyTrack1"};
ScopedTrack track2 {session, "MyTrack2"};
ScopedTrack track3 {session, "MyTrack3"};
{
Wt::WDateTime now {Wt::WDateTime::currentDateTime()};
auto transaction {session.createUniqueTransaction()};
TrackListEntry::create(session, track1.get(), trackList.get(), now);
TrackListEntry::create(session, track2.get(), trackList.get(), now.addSecs(-1));
TrackListEntry::create(session, track3.get(), trackList.get(), now.addSecs(1));
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults;
const auto tracks {trackList.get()->getTracksReverse({}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 3);
EXPECT_EQ(tracks.front()->getId(), track3.getId());
EXPECT_EQ(tracks.back()->getId(), track2.getId());
}
}
TEST_F(DatabaseFixture, SingleTrackListMultipleTrackRecentlyPlayed)
{
ScopedUser user {session, "MyUser"};
ScopedTrackList trackList {session, "MyTrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
ScopedTrack track1 {session, "MyTrack1"};
ScopedTrack track2 {session, "MyTrack1"};
ScopedArtist artist1 {session, "MyArtist1"};
ScopedArtist artist2 {session, "MyArtist2"};
ScopedRelease release1 {session, "MyRelease1"};
ScopedRelease release2 {session, "MyRelease2"};
const Wt::WDateTime now {Wt::WDateTime::currentDateTime()};
{
auto transaction {session.createUniqueTransaction()};
track1.get().modify()->setRelease(release1.get());
track2.get().modify()->setRelease(release2.get());
TrackArtistLink::create(session, track1.get(), artist1.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track2.get(), artist2.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
EXPECT_TRUE(trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getReleasesReverse({}, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getTracksReverse({}, std::nullopt, moreResults).empty());
}
{
auto transaction {session.createUniqueTransaction()};
TrackListEntry::create(session, track1.get(), trackList.get(), now);
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
const auto releases {trackList->getReleasesReverse({}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release1.getId());
const auto tracks {trackList->getTracksReverse({}, std::nullopt, moreResults)};
EXPECT_EQ(tracks.size(), 1);
}
{
auto transaction {session.createUniqueTransaction()};
TrackListEntry::create(session, track2.get(), trackList.get(), now.addSecs(1));
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists[0]->getId(), artist2.getId());
EXPECT_EQ(artists[1]->getId(), artist1.getId());
const auto releases {trackList->getReleasesReverse({}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 2);
EXPECT_EQ(releases[0]->getId(), release2.getId());
EXPECT_EQ(releases[1]->getId(), release1.getId());
const auto tracks {trackList->getTracksReverse({}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 2);
EXPECT_EQ(tracks[0]->getId(), track2.getId());
EXPECT_EQ(tracks[1]->getId(), track1.getId());
}
{
auto transaction {session.createUniqueTransaction()};
TrackListEntry::create(session, track1.get(), trackList.get(), now.addSecs(2));
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsReverse({}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists[0]->getId(), artist1.getId());
EXPECT_EQ(artists[1]->getId(), artist2.getId());
const auto releases {trackList->getReleasesReverse({}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 2);
EXPECT_EQ(releases[0]->getId(), release1.getId());
EXPECT_EQ(releases[1]->getId(), release2.getId());
const auto tracks {trackList->getTracksReverse({}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 2);
EXPECT_EQ(tracks[0]->getId(), track1.getId());
EXPECT_EQ(tracks[1]->getId(), track2.getId());
}
}
TEST_F(DatabaseFixture, SingleTrackSingleUserSingleBookmark)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
ScopedTrackBookmark bookmark {session, user.lockAndGet(), track.lockAndGet()};
{
auto transaction {session.createUniqueTransaction()};
bookmark.get().modify()->setComment("MyComment");
bookmark.get().modify()->setOffset(std::chrono::milliseconds {5});
}
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(TrackBookmark::getAll(session).size(), 1);
const auto bookmarks {TrackBookmark::getByUser(session, user.get())};
ASSERT_EQ(bookmarks.size(), 1);
EXPECT_EQ(bookmarks.back(), bookmark.get());
}
{
auto transaction {session.createSharedTransaction()};
auto userBookmark {TrackBookmark::getByUser(session, user.get(), track.get())};
ASSERT_TRUE(userBookmark);
EXPECT_EQ(userBookmark, bookmark.get());
EXPECT_EQ(userBookmark->getOffset(), std::chrono::milliseconds {5});
EXPECT_EQ(userBookmark->getComment(), "MyComment");
EXPECT_EQ(User::find(session, Range {}).results.size(), 1);
EXPECT_EQ(User::getCount(session), 1);
}
}
src/libs/services/database/test/Listen.cpp
+892
View File
@@ -0,0 +1,892 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Common.hpp"
#include "services/database/Listen.hpp"
using namespace Database;
using ScopedListen = ScopedEntity<Database::Listen>;
TEST_F(DatabaseFixture, Listen_getAll)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(Listen::getCount(session), 0);
}
ScopedListen listen {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 1}}};
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(Listen::getCount(session), 1);
}
{
auto transaction {session.createUniqueTransaction()};
ScopedListen listen2 {session, user.get(), track.get(), Scrobbler::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{13, 0, 1}}};
EXPECT_EQ(Listen::getCount(session), 2);
}
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(Listen::getCount(session), 1);
}
}
TEST_F(DatabaseFixture, Listen_get)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
ScopedListen listen {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 1}}};
{
auto transaction {session.createSharedTransaction()};
auto listens {Listen::find(session, user->getId(), Scrobbler::ListenBrainz)};
EXPECT_EQ(listens.results.size(), 0);
}
{
auto transaction {session.createSharedTransaction()};
auto listens {Listen::find(session, user->getId(), Scrobbler::Internal)};
EXPECT_EQ(listens.moreResults, false);
ASSERT_EQ(listens.results.size(), 1);
EXPECT_EQ(listens.results.front()->getId(), listen->getId());
}
}
TEST_F(DatabaseFixture, Listen_get_multi)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
ScopedListen listen3 {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 3}}};
ScopedListen listen1 {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 1}}};
ScopedListen listen2 {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, Wt::WDateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12, 0, 2}}};
{
auto transaction {session.createSharedTransaction()};
auto listens {Listen::find(session, user->getId(), Scrobbler::Internal)};
ASSERT_EQ(listens.results.size(), 3);
EXPECT_EQ(listens.results[0]->getId(), listen1.getId());
EXPECT_EQ(listens.results[1]->getId(), listen2.getId());
EXPECT_EQ(listens.results[2]->getId(), listen3.getId());
}
}
TEST_F(DatabaseFixture, Listen_get_byDateTime)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
const Wt::WDateTime dateTime1 {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
const Wt::WDateTime dateTime2 {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 2}};
ASSERT_GT(dateTime2, dateTime1);
ScopedListen listen1 {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime1};
ScopedListen listen2 {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime2};
{
auto transaction {session.createSharedTransaction()};
{
Listen::pointer listen {Listen::find(session, user.getId(), track.getId(), Scrobbler::Internal, dateTime1)};
ASSERT_TRUE(listen);
EXPECT_EQ(listen->getId(), listen1.getId());
}
{
Listen::pointer listen {Listen::find(session, user.getId(), track.getId(), Scrobbler::Internal, dateTime2)};
ASSERT_TRUE(listen);
EXPECT_EQ(listen->getId(), listen2.getId());
}
{
Listen::pointer listen {Listen::find(session, user.getId(), track.getId(), Scrobbler::Internal, dateTime2.addSecs(56))};
EXPECT_FALSE(listen);
}
}
}
TEST_F(DatabaseFixture, Listen_getTopArtists)
{
ScopedTrack track1 {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
const Wt::WDateTime dateTime1 {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
ScopedListen listen1 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime1};
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt)};
EXPECT_EQ(artists.results.size(), 0);
EXPECT_EQ(artists.moreResults, false);
}
ScopedTrack track2 {session, "MyTrack2"};
ScopedArtist artist1 {session, "MyArtist1"};
ScopedListen listen2 {session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime1.addSecs(1)};
{
auto transaction {session.createUniqueTransaction()};
TrackArtistLink::create(session, track2.get(), artist1.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt)};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results[0], artist1->getId());
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getTopArtists(session, user->getId(), Scrobbler::ListenBrainz, {}, std::nullopt)};
ASSERT_EQ(artists.results.size(), 0);
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, TrackArtistLinkType::Producer)};
EXPECT_EQ(artists.results.size(), 0);
}
{
ScopedClusterType clusterType {session, "MyType"};
ScopedCluster cluster {session, clusterType.lockAndGet(), "MyCluster"};
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {cluster->getId()}, std::nullopt)};
EXPECT_EQ(artists.results.size(), 0);
}
}
}
TEST_F(DatabaseFixture, Listen_getTopArtists_multi)
{
ScopedUser user {session, "MyUser"};
ScopedTrack track1 {session, "MyTrack1"};
ScopedArtist artist1 {session, "MyArtist1"};
ScopedTrack track2 {session, "MyTrack2"};
ScopedArtist artist2 {session, "MyArtist2"};
const Wt::WDateTime dateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
{
auto transaction {session.createUniqueTransaction()};
TrackArtistLink::create(session, track1.get(), artist1.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track2.get(), artist2.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt)};
EXPECT_EQ(artists.results.size(), 0);
}
ScopedListen listen1 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(1)};
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt)};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results[0], artist1->getId());
}
ScopedListen listen2 {session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(2)};
ScopedListen listen3 {session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(3)};
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt)};
ASSERT_EQ(artists.results.size(), 2);
EXPECT_EQ(artists.results[0], artist2->getId());
EXPECT_EQ(artists.results[1], artist1->getId());
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt, Range {0, 1})};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.moreResults, true);
EXPECT_EQ(artists.results[0], artist2->getId());
}
}
TEST_F(DatabaseFixture, Listen_getTopArtists_cluster)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
ScopedArtist artist {session, "MyArtist"};
const Wt::WDateTime dateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
ScopedListen listen {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime};
ScopedClusterType clusterType {session, "MyType"};
ScopedCluster cluster {session, clusterType.lockAndGet(), "MyCluster"};
{
auto transaction {session.createUniqueTransaction()};
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {cluster.getId()}, std::nullopt)};
ASSERT_EQ(artists.results.size(), 0);
}
{
auto transaction {session.createUniqueTransaction()};
cluster.get().modify()->addTrack(track.get());
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getTopArtists(session, user->getId(), Scrobbler::Internal, {cluster.getId()}, std::nullopt)};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results[0], artist.getId());
}
}
TEST_F(DatabaseFixture, Listen_getTopReleases)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
const Wt::WDateTime dateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
ScopedRelease release {session, "MyRelease"};
{
auto transaction {session.createSharedTransaction()};
track.get().modify()->setRelease(release.get());
}
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(releases.moreResults, false);
EXPECT_EQ(releases.results.size(), 0);
}
ScopedListen listen {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(releases.moreResults, false);
ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results[0], release.getId());
}
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getTopReleases(session, user->getId(), Scrobbler::ListenBrainz, {})};
EXPECT_EQ(releases.moreResults, false);
EXPECT_EQ(releases.results.size(), 0);
}
}
TEST_F(DatabaseFixture, Listen_getTopReleases_multi)
{
ScopedTrack track1 {session, "MyTrack"};
ScopedTrack track2 {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
const Wt::WDateTime dateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
ScopedListen listen1 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime};
ScopedRelease release1 {session, "MyRelease1"};
ScopedRelease release2 {session, "MyRelease2"};
{
auto transaction {session.createSharedTransaction()};
track1.get().modify()->setRelease(release1.get());
track2.get().modify()->setRelease(release2.get());
}
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(releases.moreResults, false);
ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results[0], release1.getId());
}
ScopedListen listen2 {session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime};
ScopedListen listen3 {session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(releases.moreResults, false);
ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], release2.getId());
EXPECT_EQ(releases.results[1], release1.getId());
}
ScopedListen listen4 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime};
ScopedListen listen5 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(releases.moreResults, false);
ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], release1.getId());
EXPECT_EQ(releases.results[1], release2.getId());
}
}
TEST_F(DatabaseFixture, Listen_getTopReleases_cluster)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
const Wt::WDateTime dateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
ScopedListen listen {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime};
ScopedClusterType clusterType {session, "MyType"};
ScopedCluster cluster {session, clusterType.lockAndGet(), "MyCluster"};
ScopedRelease release {session, "MyRelease"};
{
auto transaction {session.createSharedTransaction()};
track.get().modify()->setRelease(release.get());
}
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {cluster.getId()})};
EXPECT_EQ(releases.results.size(), 0);
}
{
auto transaction {session.createUniqueTransaction()};
cluster.get().modify()->addTrack(track.get());
}
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getTopReleases(session, user->getId(), Scrobbler::Internal, {cluster.getId()})};
EXPECT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results[0], release.getId());
}
}
TEST_F(DatabaseFixture, Listen_getTopTracks)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
const Wt::WDateTime dateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(tracks.moreResults, false);
ASSERT_EQ(tracks.results.size(), 0);
}
ScopedListen listen {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(tracks.moreResults, false);
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results[0], track.getId());
}
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getTopTracks(session, user->getId(), Scrobbler::ListenBrainz, {})};
EXPECT_EQ(tracks.moreResults, false);
EXPECT_EQ(tracks.results.size(), 0);
}
}
TEST_F(DatabaseFixture, Listen_getTopTrack_multi)
{
ScopedTrack track1 {session, "MyTrack1"};
ScopedTrack track2 {session, "MyTrack2"};
ScopedUser user {session, "MyUser"};
const Wt::WDateTime dateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
ScopedListen listen1 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(tracks.moreResults, false);
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results[0], track1.getId());
}
ScopedListen listen2 {session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime};
ScopedListen listen3 {session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(tracks.moreResults, false);
ASSERT_EQ(tracks.results.size(), 2);
EXPECT_EQ(tracks.results[0], track2.getId());
EXPECT_EQ(tracks.results[1], track1.getId());
}
ScopedListen listen4 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime};
ScopedListen listen5 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(tracks.moreResults, false);
ASSERT_EQ(tracks.results.size(), 2);
EXPECT_EQ(tracks.results[0], track1.getId());
EXPECT_EQ(tracks.results[1], track2.getId());
}
}
TEST_F(DatabaseFixture, Listen_getTopTracks_cluster)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
const Wt::WDateTime dateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
ScopedListen listen {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime};
ScopedClusterType clusterType {session, "MyType"};
ScopedCluster cluster {session, clusterType.lockAndGet(), "MyCluster"};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {cluster.getId()})};
EXPECT_EQ(tracks.results.size(), 0);
}
{
auto transaction {session.createUniqueTransaction()};
cluster.get().modify()->addTrack(track.get());
}
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getTopTracks(session, user->getId(), Scrobbler::Internal, {cluster.getId()})};
EXPECT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results[0], track.getId());
}
}
TEST_F(DatabaseFixture, Listen_getRecentArtists)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
ScopedArtist artist {session, "MyArtist"};
{
auto transaction {session.createUniqueTransaction()};
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt)};
EXPECT_EQ(artists.results.size(), 0);
EXPECT_EQ(artists.moreResults, false);
}
const Wt::WDateTime dateTime {Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1}};
ScopedListen listen1 {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt)};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results[0], artist->getId());
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getRecentArtists(session, user->getId(), Scrobbler::ListenBrainz, {}, std::nullopt)};
ASSERT_EQ(artists.results.size(), 0);
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, TrackArtistLinkType::Producer)};
EXPECT_EQ(artists.results.size(), 0);
}
{
ScopedClusterType clusterType {session, "MyType"};
ScopedCluster cluster {session, clusterType.lockAndGet(), "MyCluster"};
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {cluster->getId()}, std::nullopt)};
EXPECT_EQ(artists.results.size(), 0);
}
}
}
TEST_F(DatabaseFixture, Listen_getRecentArtists_multi)
{
ScopedUser user {session, "MyUser"};
ScopedTrack track1 {session, "MyTrack1"};
ScopedArtist artist1 {session, "MyArtist1"};
ScopedTrack track2 {session, "MyTrack2"};
ScopedArtist artist2 {session, "MyArtist2"};
const Wt::WDateTime dateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
{
auto transaction {session.createUniqueTransaction()};
TrackArtistLink::create(session, track1.get(), artist1.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track2.get(), artist2.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt)};
EXPECT_EQ(artists.results.size(), 0);
}
ScopedListen listen1 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(1)};
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt)};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results[0], artist1->getId());
}
ScopedListen listen2 {session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(2)};
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt)};
ASSERT_EQ(artists.results.size(), 2);
EXPECT_EQ(artists.results[0], artist2->getId());
EXPECT_EQ(artists.results[1], artist1->getId());
}
ScopedListen listen3 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(-1)};
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {}, std::nullopt, Range {0, 1})};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.moreResults, true);
EXPECT_EQ(artists.results[0], artist2->getId());
}
}
TEST_F(DatabaseFixture, Listen_getRecentArtists_cluster)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
ScopedArtist artist {session, "MyArtist"};
const Wt::WDateTime dateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
ScopedListen listen {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime};
ScopedClusterType clusterType {session, "MyType"};
ScopedCluster cluster {session, clusterType.lockAndGet(), "MyCluster"};
{
auto transaction {session.createUniqueTransaction()};
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {cluster.getId()}, std::nullopt)};
ASSERT_EQ(artists.results.size(), 0);
}
{
auto transaction {session.createUniqueTransaction()};
cluster.get().modify()->addTrack(track.get());
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Listen::getRecentArtists(session, user->getId(), Scrobbler::Internal, {cluster.getId()}, std::nullopt)};
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results[0], artist.getId());
}
}
TEST_F(DatabaseFixture, Listen_getRecentReleases)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
ScopedRelease release {session, "MyRelease"};
{
auto transaction {session.createSharedTransaction()};
track.get().modify()->setRelease(release.get());
}
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(releases.moreResults, false);
ASSERT_EQ(releases.results.size(), 0);
}
const Wt::WDateTime dateTime {Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1}};
ScopedListen listen1 {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(releases.moreResults, false);
ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results[0], release.getId());
}
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getRecentReleases(session, user->getId(), Scrobbler::ListenBrainz, {})};
EXPECT_EQ(releases.moreResults, false);
EXPECT_EQ(releases.results.size(), 0);
}
}
TEST_F(DatabaseFixture, Listen_getRecentReleases_multi)
{
ScopedTrack track1 {session, "MyTrack1"};
ScopedTrack track2 {session, "MyTrack2"};
ScopedUser user {session, "MyUser"};
ScopedRelease release1 {session, "MyRelease1"};
ScopedRelease release2 {session, "MyRelease2"};
{
auto transaction {session.createSharedTransaction()};
track1.get().modify()->setRelease(release1.get());
track2.get().modify()->setRelease(release2.get());
}
const Wt::WDateTime dateTime {Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1}};
ScopedListen listen1 {session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(releases.moreResults, false);
ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results[0], release2.getId());
}
ScopedListen listen2 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(1)};
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(releases.moreResults, false);
ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], release1.getId());
EXPECT_EQ(releases.results[1], release2.getId());
}
ScopedListen listen3 {session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(2)};
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(releases.moreResults, false);
ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], release2.getId());
EXPECT_EQ(releases.results[1], release1.getId());
}
ScopedListen listen4 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(-1)};
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(releases.moreResults, false);
ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], release2.getId());
EXPECT_EQ(releases.results[1], release1.getId());
}
}
TEST_F(DatabaseFixture, Listen_getRecentReleases_cluster)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
ScopedClusterType clusterType {session, "MyType"};
ScopedCluster cluster {session, clusterType.lockAndGet(), "MyCluster"};
ScopedRelease release {session, "MyRelease"};
{
auto transaction {session.createSharedTransaction()};
track.get().modify()->setRelease(release.get());
}
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {cluster.getId()})};
EXPECT_EQ(releases.results.size(), 0);
}
const Wt::WDateTime dateTime {Wt::WDate{2000, 1, 2}, Wt::WTime{12,0, 1}};
ScopedListen listen {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {cluster.getId()})};
EXPECT_EQ(releases.results.size(), 0);
}
{
auto transaction {session.createUniqueTransaction()};
cluster.get().modify()->addTrack(track.get());
}
{
auto transaction {session.createSharedTransaction()};
auto releases {Listen::getRecentReleases(session, user->getId(), Scrobbler::Internal, {cluster.getId()})};
EXPECT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results[0], release.getId());
}
}
TEST_F(DatabaseFixture, Listen_getRecentTracks)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(tracks.moreResults, false);
ASSERT_EQ(tracks.results.size(), 0);
}
const Wt::WDateTime dateTime {Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1}};
ScopedListen listen1 {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(tracks.moreResults, false);
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results[0], track.getId());
}
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getRecentTracks(session, user->getId(), Scrobbler::ListenBrainz, {})};
EXPECT_EQ(tracks.moreResults, false);
EXPECT_EQ(tracks.results.size(), 0);
}
}
TEST_F(DatabaseFixture, Listen_getRecentTracks_multi)
{
ScopedTrack track1 {session, "MyTrack1"};
ScopedTrack track2 {session, "MyTrack2"};
ScopedUser user {session, "MyUser"};
const Wt::WDateTime dateTime {Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1}};
ScopedListen listen1 {session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(tracks.moreResults, false);
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results[0], track2.getId());
}
ScopedListen listen2 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(1)};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(tracks.moreResults, false);
ASSERT_EQ(tracks.results.size(), 2);
EXPECT_EQ(tracks.results[0], track1.getId());
EXPECT_EQ(tracks.results[1], track2.getId());
}
ScopedListen listen3 {session, user.lockAndGet(), track2.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(2)};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(tracks.moreResults, false);
ASSERT_EQ(tracks.results.size(), 2);
EXPECT_EQ(tracks.results[0], track2.getId());
EXPECT_EQ(tracks.results[1], track1.getId());
}
ScopedListen listen4 {session, user.lockAndGet(), track1.lockAndGet(), Scrobbler::Internal, dateTime.addSecs(-1)};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {})};
EXPECT_EQ(tracks.moreResults, false);
ASSERT_EQ(tracks.results.size(), 2);
EXPECT_EQ(tracks.results[0], track2.getId());
EXPECT_EQ(tracks.results[1], track1.getId());
}
}
TEST_F(DatabaseFixture, Listen_getRecentTracks_cluster)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
const Wt::WDateTime dateTime {Wt::WDate {2000, 1, 2}, Wt::WTime {12,0, 1}};
ScopedListen listen {session, user.lockAndGet(), track.lockAndGet(), Scrobbler::Internal, dateTime};
ScopedClusterType clusterType {session, "MyType"};
ScopedCluster cluster {session, clusterType.lockAndGet(), "MyCluster"};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {cluster.getId()})};
EXPECT_EQ(tracks.results.size(), 0);
}
{
auto transaction {session.createUniqueTransaction()};
cluster.get().modify()->addTrack(track.get());
}
{
auto transaction {session.createSharedTransaction()};
auto tracks {Listen::getRecentTracks(session, user->getId(), Scrobbler::Internal, {cluster.getId()})};
EXPECT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results[0], track.getId());
}
}
src/libs/services/database/test/Release.cpp
+68 -65
View File
@@ -21,11 +21,12 @@
using namespace Database;
TEST_F(DatabaseFixture, SingleRelease)
TEST_F(DatabaseFixture, Release)
{
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(Release::getCount(session), 0);
EXPECT_FALSE(Release::exists(session, 0));
EXPECT_FALSE(Release::exists(session, 1));
}
@@ -35,20 +36,23 @@ TEST_F(DatabaseFixture, SingleRelease)
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(Release::getCount(session), 1);
EXPECT_TRUE(Release::exists(session, release.getId()));
auto releases {Release::getAllOrphans(session)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release.getId());
auto releases {Release::findOrphans(session, Range {})};
ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId());
releases = Release::getAll(session);
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release.getId());
EXPECT_EQ(release->getDuration(), std::chrono::seconds {0});
{
auto releases {Release::find(session, Release::FindParameters {})};
ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId());
EXPECT_EQ(release->getDuration(), std::chrono::seconds {0});
}
}
}
TEST_F(DatabaseFixture, SingleTrackSingleRelease)
TEST_F(DatabaseFixture, Release_singleTrack)
{
ScopedRelease release {session, "MyRelease"};
@@ -64,7 +68,7 @@ TEST_F(DatabaseFixture, SingleTrackSingleRelease)
{
auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Release::getAllOrphans(session).empty());
EXPECT_TRUE(Release::findOrphans(session, Range {}).results.empty());
EXPECT_EQ(release->getTracksCount(), 1);
ASSERT_EQ(release->getTracks().size(), 1);
@@ -80,19 +84,19 @@ TEST_F(DatabaseFixture, SingleTrackSingleRelease)
{
auto transaction {session.createUniqueTransaction()};
auto tracks {Track::getByNameAndReleaseName(session, "MyTrackName", "MyReleaseName")};
ASSERT_EQ(tracks.size(), 1);
EXPECT_EQ(tracks.front()->getId(), track.getId());
auto tracks {Track::findByNameAndReleaseName(session, "MyTrackName", "MyReleaseName")};
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
}
{
auto transaction {session.createUniqueTransaction()};
auto tracks {Track::getByNameAndReleaseName(session, "MyTrackName", "MyReleaseFoo")};
EXPECT_EQ(tracks.size(), 0);
auto tracks {Track::findByNameAndReleaseName(session, "MyTrackName", "MyReleaseFoo")};
EXPECT_EQ(tracks.results.size(), 0);
}
{
auto transaction {session.createUniqueTransaction()};
auto tracks {Track::getByNameAndReleaseName(session, "MyTrackFoo", "MyReleaseName")};
EXPECT_EQ(tracks.size(), 0);
auto tracks {Track::findByNameAndReleaseName(session, "MyTrackFoo", "MyReleaseName")};
EXPECT_EQ(tracks.results.size(), 0);
}
}
@@ -101,9 +105,9 @@ TEST_F(DatabaseFixture, SingleTrackSingleRelease)
EXPECT_TRUE(release->getTracks().empty());
auto releases {Release::getAllOrphans(session)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release.getId());
auto releases {Release::findOrphans(session, Range {})};
ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId());
}
}
@@ -138,38 +142,37 @@ TEST_F(DatabaseFixture, MulitpleReleaseSearchByName)
{
auto transaction {session.createSharedTransaction()};
bool more;
{
const auto releases {Release::getByFilter(session, {}, {"Release"}, std::nullopt, more)};
EXPECT_EQ(releases.size(), 6);
const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"Release"}))};
EXPECT_EQ(releases.results.size(), 6);
}
{
const auto releases {Release::getByFilter(session, {}, {"MyRelease"}, std::nullopt, more)};
EXPECT_EQ(releases.size(), 5);
EXPECT_TRUE(std::none_of(std::cbegin(releases), std::cend(releases), [&](const Release::pointer& release) { return release->getId() == release6.getId(); }));
const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"MyRelease"}))};
ASSERT_EQ(releases.results.size(), 5);
EXPECT_TRUE(std::none_of(std::cbegin(releases.results), std::cend(releases.results), [&](const ReleaseId releaseId) { return releaseId == release6.getId(); }));
}
{
const auto releases {Release::getByFilter(session, {}, {"MyRelease%"}, std::nullopt, more)};
ASSERT_EQ(releases.size(), 2);
EXPECT_EQ(releases[0]->getId(), release2.getId());
EXPECT_EQ(releases[1]->getId(), release4.getId());
const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"MyRelease%"}))};
ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], release2.getId());
EXPECT_EQ(releases.results[1], release4.getId());
}
{
const auto releases {Release::getByFilter(session, {}, {"%MyRelease"}, std::nullopt, more)};
ASSERT_EQ(releases.size(), 2);
EXPECT_EQ(releases[0]->getId(), release3.getId());
EXPECT_EQ(releases[1]->getId(), release5.getId());
const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"%MyRelease"}))};
ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], release3.getId());
EXPECT_EQ(releases.results[1], release5.getId());
}
{
const auto releases {Release::getByFilter(session, {}, {"Foo%MyRelease"}, std::nullopt, more)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases[0]->getId(), release5.getId());
const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"Foo%MyRelease"}))};
ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results[0], release5.getId());
}
{
const auto releases {Release::getByFilter(session, {}, {"MyRelease%Foo"}, std::nullopt, more)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases[0]->getId(), release4.getId());
const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"MyRelease%Foo"}))};
ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results[0], release4.getId());
}
}
}
@@ -323,8 +326,8 @@ TEST_F(DatabaseFixture, MultiTracksSingleReleaseDate)
{
auto transaction {session.createSharedTransaction()};
const auto releases {Release::getByYear(session, 0, 3000)};
EXPECT_EQ(releases.size(), 0);
const auto releases {Release::find(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(0, 3000)))};
EXPECT_EQ(releases.results.size(), 0);
}
{
@@ -348,48 +351,48 @@ TEST_F(DatabaseFixture, MultiTracksSingleReleaseDate)
{
auto transaction {session.createSharedTransaction()};
auto releases {Release::getByYear(session, 1950, 2000)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release1.getId());
auto releases {Release::find(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(1950, 2000)))};
ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release1.getId());
releases = Release::getByYear(session, 1994, 1994);
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release1.getId());
releases = Release::find(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(1994, 1994)));
ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release1.getId());
releases = Release::getByYear(session, 1993, 1993);
ASSERT_EQ(releases.size(), 0);
releases = Release::find(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(1993, 1993)));
ASSERT_EQ(releases.results.size(), 0);
}
}
TEST_F(DatabaseFixture, SingleStarredRelease)
TEST_F(DatabaseFixture, Release_writtenAfter)
{
ScopedRelease release {session, "MyRelease"};
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
{
auto transaction {session.createSharedTransaction()};
EXPECT_FALSE(user->isStarred(release.get()));
}
const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 1}, Wt::WTime {12, 30, 20}};
{
auto transaction {session.createUniqueTransaction()};
track.get().modify()->setLastWriteTime(dateTime);
track.get().modify()->setRelease(release.get());
user.get().modify()->star(release.get());
}
{
auto transaction {session.createSharedTransaction()};
const auto releases {Release::find(session, Release::FindParameters {})};
EXPECT_EQ(releases.results.size(), 1);
}
EXPECT_TRUE(user->isStarred(release.get()));
{
auto transaction {session.createSharedTransaction()};
const auto releases {Release::find(session, Release::FindParameters {}.setWrittenAfter(dateTime.addSecs(-1)))};
EXPECT_EQ(releases.results.size(), 1);
}
bool hasMore {};
auto releases {Release::getStarred(session, user.get(), {}, std::nullopt, hasMore)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release.getId());
EXPECT_FALSE(hasMore);
{
auto transaction {session.createSharedTransaction()};
const auto releases {Release::find(session, Release::FindParameters {}.setWrittenAfter(dateTime.addSecs(+1)))};
EXPECT_EQ(releases.results.size(), 0);
}
}
src/libs/services/database/test/StarredArtist.cpp
+109
View File
@@ -0,0 +1,109 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Common.hpp"
#include "services/database/StarredArtist.hpp"
using namespace Database;
using ScopedStarredArtist = ScopedEntity<Database::StarredArtist>;
TEST_F(DatabaseFixture, StarredArtist)
{
ScopedArtist artist {session, "MyArtist"};
ScopedUser user {session, "MyUser"};
ScopedUser user2 {session, "MyUser2"};
{
auto transaction {session.createSharedTransaction()};
auto starredArtist {StarredArtist::find(session, artist->getId(), user->getId(), Scrobbler::Internal)};
EXPECT_FALSE(starredArtist);
EXPECT_EQ(StarredArtist::getCount(session), 0);
auto artists {Artist::find(session, Artist::FindParameters {})};
EXPECT_EQ(artists.results.size(), 1);
}
ScopedStarredArtist starredArtist {session, artist.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
{
auto transaction {session.createSharedTransaction()};
auto gotArtist {StarredArtist::find(session, artist->getId(), user->getId(), Scrobbler::Internal)};
EXPECT_EQ(gotArtist->getId(), starredArtist->getId());
EXPECT_EQ(StarredArtist::getCount(session), 1);
}
{
auto transaction {session.createSharedTransaction()};
auto artists {Artist::find(session, Artist::FindParameters {})};
EXPECT_EQ(artists.results.size(), 1);
artists = Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal));
EXPECT_EQ(artists.results.size(), 1);
artists = Artist::find(session, Artist::FindParameters {}.setStarringUser(user2.getId(), Scrobbler::Internal));
EXPECT_EQ(artists.results.size(), 0);
}
}
TEST_F(DatabaseFixture, StarredArtist_dateTime)
{
ScopedArtist artist1 {session, "MyArtist1"};
ScopedArtist artist2 {session, "MyArtist2"};
ScopedUser user {session, "MyUser"};
ScopedStarredArtist starredArtist1 {session, artist1.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
ScopedStarredArtist starredArtist2 {session, artist2.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 2}, Wt::WTime {12, 30, 1}};
{
auto transaction {session.createSharedTransaction()};
auto artists {Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal))};
EXPECT_EQ(artists.results.size(), 2);
}
{
auto transaction {session.createUniqueTransaction()};
starredArtist1.get().modify()->setDateTime(dateTime);
starredArtist2.get().modify()->setDateTime(dateTime.addSecs(-1));
auto artists {Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal)
.setSortMethod(ArtistSortMethod::StarredDateDesc))};
ASSERT_EQ(artists.results.size(), 2);
EXPECT_EQ(artists.results[0], starredArtist1->getArtist()->getId());
EXPECT_EQ(artists.results[1], starredArtist2->getArtist()->getId());
}
{
auto transaction {session.createUniqueTransaction()};
starredArtist1.get().modify()->setDateTime(dateTime);
starredArtist2.get().modify()->setDateTime(dateTime.addSecs(1));
auto artists {Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal)
.setSortMethod(ArtistSortMethod::StarredDateDesc))};
ASSERT_EQ(artists.results.size(), 2);
EXPECT_EQ(artists.results[0], starredArtist2->getArtist()->getId());
EXPECT_EQ(artists.results[1], starredArtist1->getArtist()->getId());
}
}
src/libs/services/database/test/StarredRelease.cpp
+109
View File
@@ -0,0 +1,109 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Common.hpp"
#include "services/database/StarredRelease.hpp"
using namespace Database;
using ScopedStarredRelease = ScopedEntity<Database::StarredRelease>;
TEST_F(DatabaseFixture, StarredRelease)
{
ScopedRelease release {session, "MyRelease"};
ScopedUser user {session, "MyUser"};
ScopedUser user2 {session, "MyUser2"};
{
auto transaction {session.createSharedTransaction()};
auto starredRelease {StarredRelease::find(session, release->getId(), user->getId(), Scrobbler::Internal)};
EXPECT_FALSE(starredRelease);
EXPECT_EQ(StarredRelease::getCount(session), 0);
auto releases {Release::find(session, Release::FindParameters {})};
EXPECT_EQ(releases.results.size(), 1);
}
ScopedStarredRelease starredRelease {session, release.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
{
auto transaction {session.createSharedTransaction()};
auto gotRelease {StarredRelease::find(session, release->getId(), user->getId(), Scrobbler::Internal)};
EXPECT_EQ(gotRelease->getId(), starredRelease->getId());
EXPECT_EQ(StarredRelease::getCount(session), 1);
}
{
auto transaction {session.createSharedTransaction()};
auto releases {Release::find(session, Release::FindParameters {})};
EXPECT_EQ(releases.results.size(), 1);
releases = Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal));
EXPECT_EQ(releases.results.size(), 1);
releases = Release::find(session, Release::FindParameters {}.setStarringUser(user2.getId(), Scrobbler::Internal));
EXPECT_EQ(releases.results.size(), 0);
}
}
TEST_F(DatabaseFixture, StarredRelease_dateTime)
{
ScopedRelease release1 {session, "MyRelease1"};
ScopedRelease release2 {session, "MyRelease2"};
ScopedUser user {session, "MyUser"};
ScopedStarredRelease starredRelease1 {session, release1.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
ScopedStarredRelease starredRelease2 {session, release2.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 2}, Wt::WTime {12, 30, 1}};
{
auto transaction {session.createSharedTransaction()};
auto releases {Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal))};
EXPECT_EQ(releases.results.size(), 2);
}
{
auto transaction {session.createUniqueTransaction()};
starredRelease1.get().modify()->setDateTime(dateTime);
starredRelease2.get().modify()->setDateTime(dateTime.addSecs(-1));
auto releases {Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal)
.setSortMethod(ReleaseSortMethod::StarredDateDesc))};
ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], starredRelease1->getRelease()->getId());
EXPECT_EQ(releases.results[1], starredRelease2->getRelease()->getId());
}
{
auto transaction {session.createUniqueTransaction()};
starredRelease1.get().modify()->setDateTime(dateTime);
starredRelease2.get().modify()->setDateTime(dateTime.addSecs(1));
auto releases {Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal)
.setSortMethod(ReleaseSortMethod::StarredDateDesc))};
ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], starredRelease2->getRelease()->getId());
EXPECT_EQ(releases.results[1], starredRelease1->getRelease()->getId());
}
}
src/libs/services/database/test/StarredTrack.cpp
+109
View File
@@ -0,0 +1,109 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Common.hpp"
#include "services/database/StarredTrack.hpp"
using namespace Database;
using ScopedStarredTrack = ScopedEntity<Database::StarredTrack>;
TEST_F(DatabaseFixture, StarredTrack)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
ScopedUser user2 {session, "MyUser2"};
{
auto transaction {session.createSharedTransaction()};
auto starredTrack {StarredTrack::find(session, track->getId(), user->getId(), Scrobbler::Internal)};
EXPECT_FALSE(starredTrack);
EXPECT_EQ(StarredTrack::getCount(session), 0);
auto tracks {Track::find(session, Track::FindParameters {})};
EXPECT_EQ(tracks.results.size(), 1);
}
ScopedStarredTrack starredTrack {session, track.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
{
auto transaction {session.createSharedTransaction()};
auto gotTrack {StarredTrack::find(session, track->getId(), user->getId(), Scrobbler::Internal)};
EXPECT_EQ(gotTrack->getId(), starredTrack->getId());
EXPECT_EQ(StarredTrack::getCount(session), 1);
}
{
auto transaction {session.createSharedTransaction()};
auto tracks {Track::find(session, Track::FindParameters {})};
EXPECT_EQ(tracks.results.size(), 1);
tracks = Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal));
EXPECT_EQ(tracks.results.size(), 1);
tracks = Track::find(session, Track::FindParameters {}.setStarringUser(user2.getId(), Scrobbler::Internal));
EXPECT_EQ(tracks.results.size(), 0);
}
}
TEST_F(DatabaseFixture, StarredTrack_dateTime)
{
ScopedTrack track1 {session, "MyTrack1"};
ScopedTrack track2 {session, "MyTrack2"};
ScopedUser user {session, "MyUser"};
ScopedStarredTrack starredTrack1 {session, track1.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
ScopedStarredTrack starredTrack2 {session, track2.lockAndGet(), user.lockAndGet(), Scrobbler::Internal};
const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 2}, Wt::WTime {12, 30, 1}};
{
auto transaction {session.createSharedTransaction()};
auto tracks {Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), Scrobbler::Internal))};
EXPECT_EQ(tracks.results.size(), 2);
}
{
auto transaction {session.createUniqueTransaction()};
starredTrack1.get().modify()->setDateTime(dateTime);
starredTrack2.get().modify()->setDateTime(dateTime.addSecs(-1));
auto tracks {Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), Scrobbler::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());
}
{
auto transaction {session.createUniqueTransaction()};
starredTrack1.get().modify()->setDateTime(dateTime);
starredTrack2.get().modify()->setDateTime(dateTime.addSecs(1));
auto tracks {Track::find(session, Track::FindParameters {}.setStarringUser(user.getId(), Scrobbler::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
+34 -37
View File
@@ -23,10 +23,11 @@
using namespace Database;
TEST_F(DatabaseFixture, SingleTrack)
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));
}
@@ -36,16 +37,16 @@ TEST_F(DatabaseFixture, SingleTrack)
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(Track::getAll(session).size(), 1);
EXPECT_EQ(Track::find(session, Track::FindParameters {}).results.size(), 1);
EXPECT_EQ(Track::getCount(session), 1);
EXPECT_TRUE(Track::exists(session, track.getId()));
auto myTrack {Track::getById(session, track.getId())};
auto myTrack {Track::find(session, track.getId())};
ASSERT_TRUE(myTrack);
EXPECT_EQ(myTrack->getId(), track.getId());
}
}
TEST_F(DatabaseFixture, MultipleTracksSearchByFilter)
TEST_F(DatabaseFixture, Track_findByKeywords)
{
ScopedTrack track1 {session, ""};
ScopedTrack track2 {session, ""};
@@ -67,32 +68,31 @@ TEST_F(DatabaseFixture, MultipleTracksSearchByFilter)
{
auto transaction {session.createSharedTransaction()};
bool more;
{
const auto tracks {Track::getByFilter(session, {}, {"Track"}, std::nullopt, more)};
EXPECT_EQ(tracks.size(), 6);
const auto tracks {Track::find(session, Track::FindParameters {}.setKeywords({"Track"}))};
EXPECT_EQ(tracks.results.size(), 6);
}
{
const auto tracks {Track::getByFilter(session, {}, {"MyTrack"}, std::nullopt, more)};
EXPECT_EQ(tracks.size(), 5);
EXPECT_TRUE(std::none_of(std::cbegin(tracks), std::cend(tracks), [&](const Track::pointer& track) { return track->getId() == track6.getId(); }));
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::getByFilter(session, {}, {"MyTrack%"}, std::nullopt, more)};
ASSERT_EQ(tracks.size(), 2);
EXPECT_EQ(tracks[0]->getId(), track2.getId());
EXPECT_EQ(tracks[1]->getId(), track3.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::getByFilter(session, {}, {"%MyTrack"}, std::nullopt, more)};
ASSERT_EQ(tracks.size(), 2);
EXPECT_EQ(tracks[0]->getId(), track4.getId());
EXPECT_EQ(tracks[1]->getId(), track5.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());
}
}
}
TEST_F(DatabaseFixture, SingleTrackDate)
TEST_F(DatabaseFixture, Track_date)
{
ScopedTrack track {session, "MyTrack"};
@@ -115,36 +115,33 @@ TEST_F(DatabaseFixture, SingleTrackDate)
}
}
TEST_F(DatabaseFixture, SingleStarredTrack)
TEST_F(DatabaseFixture, Track_writtenAfter)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 1}, Wt::WTime {12, 30, 20}};
{
auto transaction {session.createUniqueTransaction()};
EXPECT_FALSE(user->isStarred(track.get()));
track.get().modify()->setLastWriteTime(dateTime);
}
{
auto transaction {session.createUniqueTransaction()};
user.get().modify()->star(track.get());
auto transaction {session.createSharedTransaction()};
const auto tracks {Track::find(session, Track::FindParameters {})};
EXPECT_EQ(tracks.results.size(), 1);
}
{
auto transaction {session.createUniqueTransaction()};
auto transaction {session.createSharedTransaction()};
const auto tracks {Track::find(session, Track::FindParameters {}.setWrittenAfter(dateTime.addSecs(-1)))};
EXPECT_EQ(tracks.results.size(), 1);
}
EXPECT_TRUE(user->isStarred(track.get()));
bool hasMore {};
auto tracks {Track::getStarred(session, user.get(), {}, std::nullopt, hasMore)};
ASSERT_EQ(tracks.size(), 1);
EXPECT_EQ(tracks.front()->getId(), track.getId());
EXPECT_FALSE(hasMore);
{
auto transaction {session.createSharedTransaction()};
const auto tracks {Track::find(session, Track::FindParameters {}.setWrittenAfter(dateTime.addSecs(+1)))};
EXPECT_EQ(tracks.results.size(), 0);
}
}
src/libs/services/database/test/TrackBookmark.cpp
+66
View File
@@ -0,0 +1,66 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Common.hpp"
#include "services/database/TrackBookmark.hpp"
using ScopedTrackBookmark = ScopedEntity<Database::TrackBookmark>;
using namespace Database;
TEST_F(DatabaseFixture, TrackBookmark)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(TrackBookmark::getCount(session), 0);
}
ScopedTrackBookmark bookmark {session, user.lockAndGet(), track.lockAndGet()};
{
auto transaction {session.createUniqueTransaction()};
bookmark.get().modify()->setComment("MyComment");
bookmark.get().modify()->setOffset(std::chrono::milliseconds {5});
}
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(TrackBookmark::getCount(session), 1);
const auto bookmarks {TrackBookmark::find(session, user.getId(), Range {})};
ASSERT_EQ(bookmarks.results.size(), 1);
EXPECT_EQ(bookmarks.results.front(), bookmark.getId());
}
{
auto transaction {session.createSharedTransaction()};
auto userBookmark {TrackBookmark::find(session, user.getId(), track.getId())};
ASSERT_TRUE(userBookmark);
EXPECT_EQ(userBookmark, bookmark.get());
EXPECT_EQ(userBookmark->getOffset(), std::chrono::milliseconds {5});
EXPECT_EQ(userBookmark->getComment(), "MyComment");
}
}
src/libs/services/database/test/TrackFeatures.cpp
+48
View File
@@ -0,0 +1,48 @@
/*
* Copyright (C) 2021 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Common.hpp"
#include "services/database/TrackFeatures.hpp"
using ScopedTrackFeatures = ScopedEntity<Database::TrackFeatures>;
using namespace Database;
TEST_F(DatabaseFixture, TrackFeatures)
{
ScopedTrack track {session, "MyTrack"};
ScopedUser user {session, "MyUser"};
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(TrackFeatures::getCount(session), 0);
}
ScopedTrackFeatures trackFeatures {session, track.lockAndGet(), ""};
{
auto transaction {session.createUniqueTransaction()};
EXPECT_EQ(TrackFeatures::getCount(session), 1);
auto allTrackFeatures {TrackFeatures::find(session, Range {})};
ASSERT_EQ(allTrackFeatures.results.size(), 1);
EXPECT_EQ(allTrackFeatures.results.front(), trackFeatures.getId());
}
}
src/libs/services/database/test/TrackList.cpp
+366
View File
@@ -0,0 +1,366 @@
/*
* Copyright (C) 2019 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include <list>
#include "Common.hpp"
using namespace Database;
TEST_F(DatabaseFixture, SingleTrackList)
{
ScopedUser user {session, "MyUser"};
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(TrackList::getCount(session), 0);
}
ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(TrackList::getCount(session), 1);
}
}
TEST_F(DatabaseFixture, SingleTrackListMultipleTrack)
{
ScopedUser user {session, "MyUser"};
ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
std::list<ScopedTrack> tracks;
for (std::size_t i {}; i < 10; ++i)
{
tracks.emplace_back(session, "MyTrack" + std::to_string(i));
auto transaction {session.createUniqueTransaction()};
TrackListEntry::create(session, tracks.back().get(), trackList.get());
}
{
auto transaction {session.createSharedTransaction()};
ASSERT_EQ(trackList->getCount(), tracks.size());
const auto trackIds {trackList->getTrackIds()};
ASSERT_EQ(trackIds.size(), tracks.size());
// Same order
std::size_t i {};
for (const ScopedTrack& track : tracks)
EXPECT_EQ(track.getId(), trackIds[i++]);
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto reverseTracks {trackList->getTracksOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(reverseTracks.size(), tracks.size());
// Reverse order
ASSERT_TRUE(tracks.size() > 0);
std::size_t i {tracks.size() - 1};
for (const ScopedTrack& track : tracks)
EXPECT_EQ(track.getId(), reverseTracks[i--]->getId());
}
}
TEST_F(DatabaseFixture, SingleTrackListMultipleTrackDateTime)
{
ScopedUser user {session, "MyUser"};
ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
ScopedTrack track1 {session, "MyTrack1"};
ScopedTrack track2 {session, "MyTrack2"};
ScopedTrack track3 {session, "MyTrack3"};
{
Wt::WDateTime now {Wt::WDateTime::currentDateTime()};
auto transaction {session.createUniqueTransaction()};
TrackListEntry::create(session, track1.get(), trackList.get(), now);
TrackListEntry::create(session, track2.get(), trackList.get(), now.addSecs(-1));
TrackListEntry::create(session, track3.get(), trackList.get(), now.addSecs(1));
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults;
const auto tracks {trackList.get()->getTracksOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 3);
EXPECT_EQ(tracks.front()->getId(), track3.getId());
EXPECT_EQ(tracks.back()->getId(), track2.getId());
}
}
TEST_F(DatabaseFixture, SingleTrackListMultipleTrackRecentlyPlayed)
{
ScopedUser user {session, "MyUser"};
ScopedTrackList trackList {session, "MyTrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
ScopedTrack track1 {session, "MyTrack1"};
ScopedTrack track2 {session, "MyTrack1"};
ScopedArtist artist1 {session, "MyArtist1"};
ScopedArtist artist2 {session, "MyArtist2"};
ScopedRelease release1 {session, "MyRelease1"};
ScopedRelease release2 {session, "MyRelease2"};
const Wt::WDateTime now {Wt::WDateTime::currentDateTime()};
{
auto transaction {session.createUniqueTransaction()};
track1.get().modify()->setRelease(release1.get());
track2.get().modify()->setRelease(release2.get());
TrackArtistLink::create(session, track1.get(), artist1.get(), TrackArtistLinkType::Artist);
TrackArtistLink::create(session, track2.get(), artist2.get(), TrackArtistLinkType::Artist);
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
EXPECT_TRUE(trackList->getArtistsOrderedByRecentFirst({}, std::nullopt, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getReleasesOrderedByRecentFirst({}, std::nullopt, moreResults).empty());
EXPECT_TRUE(trackList->getTracksOrderedByRecentFirst({}, std::nullopt, moreResults).empty());
}
{
auto transaction {session.createUniqueTransaction()};
TrackListEntry::create(session, track1.get(), trackList.get(), now);
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsOrderedByRecentFirst({}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
const auto releases {trackList->getReleasesOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 1);
EXPECT_EQ(releases.front()->getId(), release1.getId());
const auto tracks {trackList->getTracksOrderedByRecentFirst({}, std::nullopt, moreResults)};
EXPECT_EQ(tracks.size(), 1);
}
{
auto transaction {session.createUniqueTransaction()};
TrackListEntry::create(session, track2.get(), trackList.get(), now.addSecs(1));
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsOrderedByRecentFirst({}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists[0]->getId(), artist2.getId());
EXPECT_EQ(artists[1]->getId(), artist1.getId());
const auto releases {trackList->getReleasesOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 2);
EXPECT_EQ(releases[0]->getId(), release2.getId());
EXPECT_EQ(releases[1]->getId(), release1.getId());
const auto tracks {trackList->getTracksOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 2);
EXPECT_EQ(tracks[0]->getId(), track2.getId());
EXPECT_EQ(tracks[1]->getId(), track1.getId());
}
{
auto transaction {session.createUniqueTransaction()};
TrackListEntry::create(session, track1.get(), trackList.get(), now.addSecs(2));
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtistsOrderedByRecentFirst({}, std::nullopt, std::nullopt, moreResults)};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists[0]->getId(), artist1.getId());
EXPECT_EQ(artists[1]->getId(), artist2.getId());
const auto releases {trackList->getReleasesOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(releases.size(), 2);
EXPECT_EQ(releases[0]->getId(), release1.getId());
EXPECT_EQ(releases[1]->getId(), release2.getId());
const auto tracks {trackList->getTracksOrderedByRecentFirst({}, std::nullopt, moreResults)};
ASSERT_EQ(tracks.size(), 2);
EXPECT_EQ(tracks[0]->getId(), track1.getId());
EXPECT_EQ(tracks[1]->getId(), track2.getId());
}
}
TEST_F(DatabaseFixture, SingleTrackList_getArtists)
{
ScopedUser user {session, "MyUser"};
ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
ScopedTrack track1 {session, "MyTrack1"};
ScopedTrack track2 {session, "MyTrack2"};
ScopedRelease release {session, "MyRelease"};
ScopedArtist artist1 {session, "MyArtist1"};
ScopedArtist artist2 {session, "MyArtist2"};
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(trackList->getCount(), 0);
bool moreResults {};
const auto artists {trackList->getArtists({} /*clusters*/, std::nullopt /* linkType */, ArtistSortMethod::ByName, std::nullopt /* range */, moreResults)};
ASSERT_TRUE(artists.empty());
}
{
auto transaction {session.createUniqueTransaction()};
TrackArtistLink::create(session, track1.get(), artist1.get(), TrackArtistLinkType::Artist);
TrackListEntry::create(session, track1.get(), trackList.get());
}
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(trackList->getCount(), 1);
bool moreResults {};
const auto artists {trackList->getArtists({} /*clusters*/, std::nullopt /* linkType */, ArtistSortMethod::ByName, std::nullopt /* range */, moreResults)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtists({} /*clusters*/, TrackArtistLinkType::ReleaseArtist, ArtistSortMethod::ByName, std::nullopt /* range */, moreResults)};
EXPECT_TRUE(artists.empty());
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtists({} /*clusters*/, TrackArtistLinkType::Artist, ArtistSortMethod::ByName, std::nullopt /* range */, moreResults)};
ASSERT_EQ(artists.size(), 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
}
{
auto transaction {session.createUniqueTransaction()};
TrackArtistLink::create(session, track2.get(), artist2.get(), TrackArtistLinkType::Artist);
TrackListEntry::create(session, track2.get(), trackList.get());
artist1.get().modify()->setSortName("ZZZ");
artist2.get().modify()->setSortName("AAA");
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtists({} /*clusters*/, TrackArtistLinkType::Artist, ArtistSortMethod::ByName, std::nullopt /* range */, moreResults)};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists.front()->getId(), artist1.getId());
EXPECT_EQ(artists.back()->getId(), artist2.getId());
}
{
auto transaction {session.createSharedTransaction()};
bool moreResults {};
const auto artists {trackList->getArtists({} /*clusters*/, TrackArtistLinkType::Artist, ArtistSortMethod::BySortName, std::nullopt /* range */, moreResults)};
ASSERT_EQ(artists.size(), 2);
EXPECT_EQ(artists.front()->getId(), artist2.getId());
EXPECT_EQ(artists.back()->getId(), artist1.getId());
}
}
TEST_F(DatabaseFixture, SingleTrackList_getReleases)
{
ScopedUser user {session, "MyUser"};
ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
ScopedTrack track {session, "MyTrack"};
ScopedRelease release {session, "MyRelease"};
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(trackList->getCount(), 0);
bool moreResults {};
const auto releases {trackList->getReleases({} /*clusters*/, std::nullopt /* range */, moreResults)};
ASSERT_TRUE(releases.empty());
}
{
auto transaction {session.createUniqueTransaction()};
track.get().modify()->setRelease(release.get());
TrackListEntry::create(session, track.get(), trackList.get());
}
{
auto transaction {session.createSharedTransaction()};
ASSERT_EQ(trackList->getCount(), 1);
bool moreResults {};
const auto releases {trackList->getReleases({} /*clusters*/, std::nullopt /* range */, moreResults)};
ASSERT_EQ(releases.size(), 1);
ASSERT_EQ(releases.front()->getId(), release->getId());
}
}
TEST_F(DatabaseFixture, SingleTrackList_getTracks)
{
ScopedUser user {session, "MyUser"};
ScopedTrackList trackList {session, "MytrackList", TrackList::Type::Playlist, false, user.lockAndGet()};
ScopedTrack track1 {session, "MyTrack1"};
ScopedTrack track2 {session, "MyTrack1"};
{
auto transaction {session.createSharedTransaction()};
EXPECT_EQ(trackList->getCount(), 0);
bool moreResults {};
const auto tracks {trackList->getTracks({} /*clusters*/, std::nullopt /* range */, moreResults)};
ASSERT_TRUE(tracks.empty());
}
{
auto transaction {session.createUniqueTransaction()};
TrackListEntry::create(session, track1.get(), trackList.get());
TrackListEntry::create(session, track2.get(), trackList.get());
TrackListEntry::create(session, track1.get(), trackList.get());
}
{
auto transaction {session.createSharedTransaction()};
ASSERT_EQ(trackList->getCount(), 3);
bool moreResults {};
const auto tracks {trackList->getTracks({} /*clusters*/, std::nullopt /* range */, moreResults)};
ASSERT_EQ(tracks.size(), 2);
ASSERT_EQ(tracks[0]->getId(), track1->getId());
ASSERT_EQ(tracks[1]->getId(), track2->getId());
}
}