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

Subsonic API: added discTitles field in Albums

Browse Source
This commit is contained in:
emeric
2023-10-06 09:39:40 +02:00
parent 621e1f98db
commit 4329efb536
7 changed files with 616 additions and 547 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/services/database/impl/Release.cpp
+119 -124
View File
@@ -35,10 +35,9 @@
namespace Database
{
Wt::Dbo::Query<ReleaseId>
createQuery(Session& session, const Release::FindParameters& params)
{
auto query {session.getDboSession().query<ReleaseId>("SELECT DISTINCT r.id from release r")};
Wt::Dbo::Query<ReleaseId> createQuery(Session& session, const Release::FindParameters& params)
{
auto query{ session.getDboSession().query<ReleaseId>("SELECT DISTINCT r.id from release r") };
if (params.sortMethod == ReleaseSortMethod::LastWritten
|| params.sortMethod == ReleaseSortMethod::Date
@@ -82,7 +81,7 @@ createQuery(Session& session, const Release::FindParameters& params)
{
std::ostringstream oss;
bool first {true};
bool first{ true };
for (TrackArtistLinkType linkType : params.trackArtistLinkTypes)
{
if (!first)
@@ -106,7 +105,7 @@ createQuery(Session& session, const Release::FindParameters& params)
query.bind(params.artist);
bool first {true};
bool first{ true };
for (const TrackArtistLinkType linkType : params.excludedTrackArtistLinkTypes)
{
if (!first)
@@ -176,153 +175,157 @@ createQuery(Session& session, const Release::FindParameters& params)
}
return query;
}
}
Release::Release(const std::string& name, const std::optional<UUID>& MBID)
: _name {std::string(name, 0 , _maxNameLength)},
_MBID {MBID ? MBID->getAsString() : ""}
{
}
Release::Release(const std::string& name, const std::optional<UUID>& MBID)
: _name{ std::string(name, 0 , _maxNameLength) },
_MBID{ MBID ? MBID->getAsString() : "" }
{
}
Release::pointer
Release::create(Session& session, const std::string& name, const std::optional<UUID>& MBID)
{
return session.getDboSession().add(std::unique_ptr<Release> {new Release {name, MBID}});
}
Release::pointer Release::create(Session& session, const std::string& name, const std::optional<UUID>& MBID)
{
return session.getDboSession().add(std::unique_ptr<Release> {new Release{ name, MBID }});
}
std::vector<Release::pointer>
Release::find(Session& session, const std::string& name)
{
std::vector<Release::pointer> Release::find(Session& session, const std::string& name)
{
session.checkUniqueLocked();
auto res {session.getDboSession()
auto res{ session.getDboSession()
.find<Release>()
.where("name = ?").bind( std::string(name, 0, _maxNameLength) )
.resultList()};
.where("name = ?").bind(std::string(name, 0, _maxNameLength))
.resultList() };
return std::vector<Release::pointer>(res.begin(), res.end());
}
}
Release::pointer
Release::find(Session& session, const UUID& mbid)
{
Release::pointer Release::find(Session& session, const UUID& mbid)
{
session.checkSharedLocked();
return session.getDboSession()
.find<Release>()
.where("mbid = ?").bind(std::string {mbid.getAsString()})
.where("mbid = ?").bind(std::string{ mbid.getAsString() })
.resultValue();;
}
}
Release::pointer
Release::find(Session& session, ReleaseId id)
{
Release::pointer Release::find(Session& session, ReleaseId id)
{
session.checkSharedLocked();
return session.getDboSession()
.find<Release>()
.where("id = ?").bind(id)
.resultValue();
}
}
bool
Release::exists(Session& session, ReleaseId id)
{
bool Release::exists(Session& session, ReleaseId id)
{
session.checkSharedLocked();
return session.getDboSession().query<int>("SELECT 1 FROM release").where("id = ?").bind(id).resultValue() == 1;
}
}
std::size_t
Release::getCount(Session& session)
{
std::size_t Release::getCount(Session& session)
{
session.checkSharedLocked();
return session.getDboSession().query<int>("SELECT COUNT(*) FROM release");
}
}
RangeResults<ReleaseId>
Release::findOrderedByArtist(Session& session, Range range)
{
RangeResults<ReleaseId> Release::findOrderedByArtist(Session& session, Range range)
{
session.checkSharedLocked();
// TODO merge with find
auto query {session.getDboSession().query<ReleaseId>(
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")
.orderBy("a.name COLLATE NOCASE, r.name COLLATE NOCASE")};
.orderBy("a.name COLLATE NOCASE, r.name COLLATE NOCASE") };
return Utils::execQuery(query, range);
}
}
RangeResults<ReleaseId>
Release::findOrphans(Session& session, Range range)
{
RangeResults<ReleaseId> Release::findOrphans(Session& session, Range range)
{
session.checkSharedLocked();
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")};
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 Utils::execQuery(query, range);
}
}
RangeResults<ReleaseId>
Release::find(Session& session, const FindParameters& params)
{
RangeResults<ReleaseId> Release::find(Session& session, const FindParameters& params)
{
session.checkSharedLocked();
auto query {createQuery(session, params)};
auto query{ createQuery(session, params) };
return Utils::execQuery(query, params.range);
}
}
std::size_t
Release::getDiscCount() const
{
std::size_t Release::getDiscCount() const
{
assert(session());
int res {session()->query<int>("SELECT COUNT(DISTINCT disc_number) FROM track t")
int res{ session()->query<int>("SELECT COUNT(DISTINCT disc_number) FROM track t")
.join("release r ON r.id = t.release_id")
.where("r.id = ?")
.bind(getId())};
.bind(getId()) };
return res;
}
}
Wt::WDate
Release::getReleaseDate() const
{
std::vector<DiscInfo> Release::getDiscs() const
{
assert(session());
using ResultType = std::tuple<int, std::string>;
auto results{ session()->query<ResultType>("SELECT DISTINCT disc_number, disc_subtitle FROM track t")
.join("release r ON r.id = t.release_id")
.where("r.id = ?")
.orderBy("disc_number")
.bind(getId())
.resultList() };
std::vector<DiscInfo> discs;
for (const auto& res : results)
discs.emplace_back(DiscInfo{ static_cast<std::size_t>(std::get<int>(res)), std::get<std::string>(res) });
return discs;
}
Wt::WDate Release::getReleaseDate() const
{
return getReleaseDate(false);
}
}
Wt::WDate
Release::getOriginalReleaseDate() const
{
Wt::WDate Release::getOriginalReleaseDate() const
{
return getReleaseDate(true);
}
}
Wt::WDate
Release::getReleaseDate(bool original) const
{
Wt::WDate Release::getReleaseDate(bool original) const
{
assert(session());
const char* field {original ? "original_date" : "date"};
const char* field{ original ? "original_date" : "date" };
auto dates {session()->query<Wt::WDate>(
auto dates{ session()->query<Wt::WDate>(
std::string {"SELECT "} + "t." + field + " FROM track t INNER JOIN release r ON r.id = t.release_id")
.where("r.id = ?")
.groupBy(field)
.bind(getId())
.resultList()};
.resultList() };
// various dates => invalid date
if (dates.empty() || dates.size() > 1)
return {};
return dates.front();
}
}
std::optional<std::string>
Release::getCopyright() const
{
std::optional<std::string> Release::getCopyright() const
{
assert(session());
Wt::Dbo::collection<std::string> copyrights = session()->query<std::string>
@@ -338,11 +341,10 @@ Release::getCopyright() const
return std::nullopt;
return values.front();
}
}
std::optional<std::string>
Release::getCopyrightURL() const
{
std::optional<std::string> Release::getCopyrightURL() const
{
assert(session());
Wt::Dbo::collection<std::string> copyrights = session()->query<std::string>
@@ -358,31 +360,29 @@ Release::getCopyrightURL() const
return std::nullopt;
return values.front();
}
}
std::vector<Artist::pointer>
Release::getArtists(TrackArtistLinkType linkType) const
{
std::vector<Artist::pointer> Release::getArtists(TrackArtistLinkType linkType) const
{
assert(session());
auto res {session()->query<Wt::Dbo::ptr<Artist>>(
auto res{ session()->query<Wt::Dbo::ptr<Artist>>(
"SELECT DISTINCT a 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 release r ON r.id = t.release_id")
.where("r.id = ?").bind(getId())
.where("t_a_l.type = ?").bind(linkType)
.resultList()};
.resultList() };
return std::vector<Artist::pointer>(res.begin(), res.end());
}
}
std::vector<Release::pointer>
Release::getSimilarReleases(std::optional<std::size_t> offset, std::optional<std::size_t> count) const
{
std::vector<Release::pointer> Release::getSimilarReleases(std::optional<std::size_t> offset, std::optional<std::size_t> count) const
{
assert(session());
auto res {session()->query<Wt::Dbo::ptr<Release>>(
auto res{ session()->query<Wt::Dbo::ptr<Release>>(
"SELECT r 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"
@@ -396,51 +396,46 @@ Release::getSimilarReleases(std::optional<std::size_t> offset, std::optional<std
.orderBy("COUNT(*) DESC, RANDOM()")
.limit(count ? static_cast<int>(*count) : -1)
.offset(offset ? static_cast<int>(*offset) : -1)
.resultList()};
.resultList() };
return std::vector<pointer>(res.begin(), res.end());
}
}
bool
Release::hasVariousArtists() const
{
bool Release::hasVariousArtists() const
{
// TODO optimize
return getArtists().size() > 1;
}
}
std::size_t
Release::getTracksCount() const
{
std::size_t Release::getTracksCount() const
{
return _tracks.size();
}
}
std::chrono::milliseconds
Release::getDuration() const
{
std::chrono::milliseconds Release::getDuration() const
{
assert(session());
using milli = std::chrono::duration<int, std::milli>;
Wt::Dbo::Query<milli> query {session()->query<milli>("SELECT COALESCE(SUM(duration), 0) FROM track t INNER JOIN release r ON t.release_id = r.id")
.where("r.id = ?").bind(getId())};
Wt::Dbo::Query<milli> query{ session()->query<milli>("SELECT COALESCE(SUM(duration), 0) FROM track t INNER JOIN release r ON t.release_id = r.id")
.where("r.id = ?").bind(getId()) };
return query.resultValue();
}
}
Wt::WDateTime
Release::getLastWritten() const
{
Wt::WDateTime Release::getLastWritten() const
{
assert(session());
Wt::Dbo::Query<Wt::WDateTime> query {session()->query<Wt::WDateTime>("SELECT COALESCE(MAX(file_last_write), '1970-01-01T00:00:00') FROM track t INNER JOIN release r ON t.release_id = r.id")
.where("r.id = ?").bind(getId())};
Wt::Dbo::Query<Wt::WDateTime> query{ session()->query<Wt::WDateTime>("SELECT COALESCE(MAX(file_last_write), '1970-01-01T00:00:00') FROM track t INNER JOIN release r ON t.release_id = r.id")
.where("r.id = ?").bind(getId()) };
return query.resultValue();
}
}
std::vector<std::vector<Cluster::pointer>>
Release::getClusterGroups(const std::vector<ClusterType::pointer>& clusterTypes, std::size_t size) const
{
std::vector<std::vector<Cluster::pointer>> Release::getClusterGroups(const std::vector<ClusterType::pointer>& clusterTypes, std::size_t size) const
{
assert(session());
WhereClause where;
@@ -459,11 +454,11 @@ Release::getClusterGroups(const std::vector<ClusterType::pointer>& clusterTypes,
oss << " " << where.get();
oss << " GROUP BY c.id ORDER BY COUNT(c.id) DESC";
auto query {session()->query<Wt::Dbo::ptr<Cluster>>(oss.str())};
auto query{ session()->query<Wt::Dbo::ptr<Cluster>>(oss.str()) };
for (const std::string& bindArg : where.getBindArgs())
query.bind(bindArg);
auto queryRes {query.resultList()};
auto queryRes{ query.resultList() };
std::map<ClusterTypeId, std::vector<Cluster::pointer>> clustersByType;
for (const Wt::Dbo::ptr<Cluster>& cluster : queryRes)
@@ -477,6 +472,6 @@ Release::getClusterGroups(const std::vector<ClusterType::pointer>& clusterTypes,
res.push_back(clusters);
return res;
}
}
} // namespace Database
src/libs/services/database/include/services/database/Release.hpp
+19 -19
View File
@@ -37,22 +37,22 @@
namespace Database
{
class Artist;
class Cluster;
class ClusterType;
class Release;
class Session;
class Track;
class User;
class Artist;
class Cluster;
class ClusterType;
class Release;
class Session;
class Track;
class User;
class Release final : public Object<Release, ReleaseId>
{
class Release final : 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};
ReleaseSortMethod sortMethod{ ReleaseSortMethod::None };
Range range;
Wt::WDateTime writtenAfter;
std::optional<DateRange> dateRange;
@@ -66,10 +66,10 @@ class Release final : public Object<Release, ReleaseId>
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& 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; }
FindParameters& setArtist(ArtistId _artist, EnumSet<TrackArtistLinkType> _trackArtistLinkTypes = {}, EnumSet<TrackArtistLinkType> _excludedTrackArtistLinkTypes = {})
{
@@ -92,8 +92,6 @@ class Release final : public Object<Release, ReleaseId>
static RangeResults<ReleaseId> findOrphans(Session& session, Range range); // no track related
static RangeResults<ReleaseId> findOrderedByArtist(Session& session, Range range);
std::size_t getTracksCount() 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)
// size is the max number of cluster per cluster type
@@ -110,10 +108,12 @@ class Release final : public Object<Release, ReleaseId>
std::optional<UUID> getMBID() const { return UUID::fromString(_MBID); }
std::optional<std::size_t> getTotalDisc() const { return _totalDisc; }
std::size_t getDiscCount() const; // may not be total disc (if incomplete for example)
std::vector<DiscInfo> getDiscs() const;
std::chrono::milliseconds getDuration() const;
Wt::WDateTime getLastWritten() const;
std::optional<ReleaseTypePrimary> getPrimaryType() const { return _primaryType; }
EnumSet<ReleaseTypeSecondary> getSecondaryTypes() const { return _secondaryTypes; }
std::size_t getTracksCount() const;
// Setters
void setName(std::string_view name) { _name = name; }
@@ -148,16 +148,16 @@ class Release final : public Object<Release, ReleaseId>
Wt::WDate getReleaseDate(bool original) const;
static constexpr std::size_t _maxNameLength {128};
static constexpr std::size_t _maxNameLength{ 128 };
std::string _name;
std::string _MBID;
std::optional<int> _totalDisc {};
std::optional<int> _totalDisc{};
std::optional<ReleaseTypePrimary> _primaryType;
EnumSet<ReleaseTypeSecondary> _secondaryTypes;
Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _tracks; // Tracks in the release
};
};
} // namespace Database
src/libs/services/database/include/services/database/Types.hpp
+6
View File
@@ -83,6 +83,12 @@ namespace Database
static DateRange fromYearRange(int from, int to);
};
struct DiscInfo
{
std::size_t position;
std::string name;
};
enum class ArtistSortMethod
{
None,
src/libs/subsonic/CMakeLists.txt
+1
View File
@@ -13,6 +13,7 @@ add_library(lmssubsonic SHARED
impl/responses/Artist.cpp
impl/responses/Bookmark.cpp
impl/responses/Contributor.cpp
impl/responses/DiscTitle.cpp
impl/responses/Genre.cpp
impl/responses/Playlist.cpp
impl/responses/Song.cpp
src/libs/subsonic/impl/responses/Album.cpp
+6
View File
@@ -28,6 +28,7 @@
#include "utils/String.hpp"
#include "responses/Artist.hpp"
#include "responses/DiscTitle.hpp"
#include "SubsonicId.hpp"
namespace API::Subsonic
@@ -175,6 +176,11 @@ namespace API::Subsonic
for (const ReleaseTypeSecondary releaseType : release->getSecondaryTypes())
albumNode.addArrayValue("releaseTypes", toString(releaseType));
// disc titles
albumNode.createEmptyArrayChild("discTitles");
for (const DiscInfo& discInfo : release->getDiscs())
albumNode.addArrayChild("discTitles", createDiscTitle(discInfo));
return albumNode;
}
}
src/libs/subsonic/impl/responses/DiscTitle.cpp
+33
View File
@@ -0,0 +1,33 @@
/*
* Copyright (C) 2023 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 "responses/DiscTitle.hpp"
namespace API::Subsonic
{
Response::Node createDiscTitle(const Database::DiscInfo& discInfo)
{
Response::Node discTitleNode;
discTitleNode.setAttribute("disc", discInfo.position);
discTitleNode.setAttribute("title", discInfo.name);
return discTitleNode;
}
}
src/libs/subsonic/impl/responses/DiscTitle.hpp
+28
View File
@@ -0,0 +1,28 @@
/*
* Copyright (C) 2023 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/Types.hpp"
#include "SubsonicResponse.hpp"
namespace API::Subsonic
{
Response::Node createDiscTitle(const Database::DiscInfo& discInfo);
}