Extracted user management

2023-10-01 20:42:04 +02:00
parent abcf9e5b49
commit 9d879e66b7
20 changed files with 465 additions and 293 deletions
@@ -0,0 +1,104 @@
+/*
+ * 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 "Bookmark.hpp"
+
+#include "services/database/Session.hpp"
+#include "services/database/User.hpp"
+#include "services/database/Track.hpp"
+#include "services/database/TrackBookmark.hpp"
+#include "responses/Bookmark.hpp"
+#include "responses/Song.hpp"
+#include "ParameterParsing.hpp"
+#include "SubsonicId.hpp"
+
+namespace API::Subsonic
+{
+    using namespace Database;
+
+    Response handleGetBookmarks(RequestContext& context)
+    {
+        auto transaction{ context.dbSession.createSharedTransaction() };
+
+        User::pointer user{ User::find(context.dbSession, context.userId) };
+        if (!user)
+            throw UserNotAuthorizedError{};
+
+        const auto bookmarkIds{ TrackBookmark::find(context.dbSession, user->getId(), Range {}) };
+
+        Response response{ Response::createOkResponse(context.serverProtocolVersion) };
+        Response::Node& bookmarksNode{ response.createNode("bookmarks") };
+
+        for (const TrackBookmarkId bookmarkId : bookmarkIds.results)
+        {
+            const TrackBookmark::pointer bookmark{ TrackBookmark::find(context.dbSession, bookmarkId) };
+            Response::Node bookmarkNode{ createBookmarkNode(bookmark) };
+            bookmarkNode.addArrayChild("entry", createSongNode(bookmark->getTrack(), context.dbSession, user));
+
+            bookmarksNode.addArrayChild("bookmark", std::move(bookmarkNode));
+        }
+
+        return response;
+    }
+
+    Response handleCreateBookmark(RequestContext& context)
+    {
+        // Mandatory params
+        TrackId trackId{ getMandatoryParameterAs<TrackId>(context.parameters, "id") };
+        unsigned long position{ getMandatoryParameterAs<unsigned long>(context.parameters, "position") };
+        const std::optional<std::string> comment{ getParameterAs<std::string>(context.parameters, "comment") };
+
+        auto transaction{ context.dbSession.createUniqueTransaction() };
+
+        const User::pointer user{ User::find(context.dbSession, context.userId) };
+        if (!user)
+            throw UserNotAuthorizedError{};
+
+        const Track::pointer track{ Track::find(context.dbSession, trackId) };
+        if (!track)
+            throw RequestedDataNotFoundError{};
+
+        // Replace any existing bookmark
+        auto bookmark{ TrackBookmark::find(context.dbSession, user->getId(), trackId) };
+        if (!bookmark)
+            bookmark = context.dbSession.create<TrackBookmark>(user, track);
+
+        bookmark.modify()->setOffset(std::chrono::milliseconds{ position });
+        if (comment)
+            bookmark.modify()->setComment(*comment);
+
+        return Response::createOkResponse(context.serverProtocolVersion);
+    }
+
+    Response handleDeleteBookmark(RequestContext& context)
+    {
+        // Mandatory params
+        TrackId trackId{ getMandatoryParameterAs<TrackId>(context.parameters, "id") };
+
+        auto transaction{ context.dbSession.createUniqueTransaction() };
+
+        auto bookmark{ TrackBookmark::find(context.dbSession, context.userId, trackId) };
+        if (!bookmark)
+            throw RequestedDataNotFoundError{};
+
+        bookmark.remove();
+
+        return Response::createOkResponse(context.serverProtocolVersion);
+    }
+}
@@ -0,0 +1,30 @@
+/*
+ * 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 "RequestContext.hpp"
+#include "SubsonicResponse.hpp"
+
+namespace API::Subsonic
+{
+    Response handleGetBookmarks(RequestContext& context);
+    Response handleCreateBookmark(RequestContext& context);
+    Response handleDeleteBookmark(RequestContext& context);
+}
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2020 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 "Scan.hpp"
+
+#include "services/scanner/IScannerService.hpp"
+#include "utils/Service.hpp"
+
+namespace API::Subsonic::Scan
+{
+	using namespace Scanner;
+
+	static
+	Response::Node
+	createStatusResponseNode()
+	{
+		Response::Node statusResponse;
+
+		const IScannerService::Status scanStatus {Service<IScannerService>::get()->getStatus()};
+
+		statusResponse.setAttribute("scanning", scanStatus.currentState == IScannerService::State::InProgress);
+		if (scanStatus.currentState == IScannerService::State::InProgress)
+		{
+			std::size_t count{};
+
+			if (scanStatus.currentScanStepStats && scanStatus.currentScanStepStats->currentStep == ScanStep::ScanningFiles)
+				count = scanStatus.currentScanStepStats->processedElems;
+
+			statusResponse.setAttribute("count", count);
+		}
+
+		return statusResponse;
+	}
+
+
+	Response
+	handleGetScanStatus(RequestContext& context)
+	{
+		Response response {Response::createOkResponse(context.serverProtocolVersion)};
+		response.addNode("scanStatus", createStatusResponseNode());
+
+		return response;
+	}
+
+	Response
+	handleStartScan(RequestContext& context)
+	{
+		Service<IScannerService>::get()->requestImmediateScan(false);
+
+		Response response {Response::createOkResponse(context.serverProtocolVersion)};
+		response.addNode("scanStatus", createStatusResponseNode());
+
+		return response;
+	}
+}
+
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2020 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 "RequestContext.hpp"
+#include "SubsonicResponse.hpp"
+
+namespace API::Subsonic::Scan
+{
+	Response handleGetScanStatus(RequestContext& context);
+	Response handleStartScan(RequestContext& context);
+}
+
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2020 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 "Stream.hpp"
+
+#include "av/TranscodeParameters.hpp"
+#include "av/TranscodeResourceHandlerCreator.hpp"
+#include "av/Types.hpp"
+#include "services/database/Session.hpp"
+#include "services/database/Track.hpp"
+#include "services/database/User.hpp"
+#include "utils/IResourceHandler.hpp"
+#include "utils/Logger.hpp"
+#include "utils/FileResourceHandlerCreator.hpp"
+#include "utils/Utils.hpp"
+#include "ParameterParsing.hpp"
+#include "SubsonicId.hpp"
+
+using namespace Database;
+
+namespace API::Subsonic::Stream
+{
+
+static
+Av::Format
+userTranscodeFormatToAvFormat(AudioFormat format)
+{
+	switch (format)
+	{
+		case AudioFormat::MP3:			return Av::Format::MP3;
+		case AudioFormat::OGG_OPUS:		return Av::Format::OGG_OPUS;
+		case AudioFormat::MATROSKA_OPUS:	return Av::Format::MATROSKA_OPUS;
+		case AudioFormat::OGG_VORBIS:		return Av::Format::OGG_VORBIS;
+		case AudioFormat::WEBM_VORBIS:		return Av::Format::WEBM_VORBIS;
+		default:				return Av::Format::OGG_OPUS;
+	}
+}
+
+struct StreamParameters
+{
+	Av::InputFileParameters inputFileParameters;
+	std::optional<Av::TranscodeParameters> transcodeParameters;
+	bool estimateContentLength {};
+};
+
+static
+StreamParameters
+getStreamParameters(RequestContext& context)
+{
+	// Mandatory params
+	const TrackId id {getMandatoryParameterAs<TrackId>(context.parameters, "id")};
+
+	// Optional params
+	std::optional<std::size_t> maxBitRate {getParameterAs<std::size_t>(context.parameters, "maxBitRate")};
+	std::optional<std::string> format {getParameterAs<std::string>(context.parameters, "format")};
+	bool estimateContentLength {getParameterAs<bool>(context.parameters, "estimateContentLength").value_or(false)};
+
+	StreamParameters parameters;
+
+	parameters.estimateContentLength = estimateContentLength;
+
+	auto transaction {context.dbSession.createSharedTransaction()};
+
+	{
+		auto track {Track::find(context.dbSession, id)};
+		if (!track)
+			throw RequestedDataNotFoundError {};
+
+		parameters.inputFileParameters.trackPath = track->getPath();
+		parameters.inputFileParameters.duration = track->getDuration();
+	}
+
+	{
+		const User::pointer user {User::find(context.dbSession, context.userId)};
+		if (!user)
+			throw UserNotAuthorizedError {};
+
+		// format = "raw" => no transcode. Other format values will be ignored
+		const bool transcode {(!format || (*format != "raw")) && user->getSubsonicTranscodeEnable()};
+		if (transcode)
+		{
+			std::size_t bitRate {user->getSubsonicTranscodeBitrate() / 1000};
+
+			// "If set to zero, no limit is imposed"
+			if (maxBitRate && *maxBitRate != 0)
+				bitRate = Utils::clamp(*maxBitRate, std::size_t {48}, bitRate);
+
+			Av::TranscodeParameters transcodeParameters;
+
+			transcodeParameters.bitrate = bitRate * 1000;
+			transcodeParameters.format = userTranscodeFormatToAvFormat(user->getSubsonicTranscodeFormat());
+			transcodeParameters.stripMetadata = false; // We want clients to use metadata (offline use, replay gain, etc.)
+
+			parameters.transcodeParameters = std::move(transcodeParameters);
+		}
+	}
+
+	return parameters;
+}
+
+void
+handleDownload(RequestContext& context, const Wt::Http::Request& request, Wt::Http::Response& response)
+{
+	std::shared_ptr<IResourceHandler> resourceHandler;
+
+	Wt::Http::ResponseContinuation* continuation {request.continuation()};
+	if (!continuation)
+	{
+		// Mandatory params
+		Database::TrackId id {getMandatoryParameterAs<Database::TrackId>(context.parameters, "id")};
+
+		std::filesystem::path trackPath;
+		{
+			auto transaction {context.dbSession.createSharedTransaction()};
+
+			auto track {Track::find(context.dbSession, id)};
+			if (!track)
+				throw RequestedDataNotFoundError {};
+
+			trackPath = track->getPath();
+		}
+
+		resourceHandler = createFileResourceHandler(trackPath);
+	}
+	else
+	{
+		resourceHandler = Wt::cpp17::any_cast<std::shared_ptr<IResourceHandler>>(continuation->data());
+	}
+
+	continuation = resourceHandler->processRequest(request, response);
+	if (continuation)
+		continuation->setData(resourceHandler);
+}
+
+void
+handleStream(RequestContext& context, const Wt::Http::Request& request, Wt::Http::Response& response)
+{
+	std::shared_ptr<IResourceHandler> resourceHandler;
+
+	try
+	{
+		Wt::Http::ResponseContinuation* continuation = request.continuation();
+		if (!continuation)
+		{
+			StreamParameters streamParameters {getStreamParameters(context)};
+			if (streamParameters.transcodeParameters)
+				resourceHandler = Av::createTranscodeResourceHandler(streamParameters.inputFileParameters, *streamParameters.transcodeParameters, streamParameters.estimateContentLength);
+			else
+				resourceHandler = createFileResourceHandler(streamParameters.inputFileParameters.trackPath);
+		}
+		else
+		{
+			resourceHandler = Wt::cpp17::any_cast<std::shared_ptr<IResourceHandler>>(continuation->data());
+		}
+
+		continuation = resourceHandler->processRequest(request, response);
+		if (continuation)
+			continuation->setData(resourceHandler);
+	}
+	catch (const Av::Exception& e)
+	{
+		LMS_LOG(API_SUBSONIC, ERROR) << "Caught Av exception: " << e.what();
+	}
+}
+
+} // namespace API::Subsonic::Stream
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2020 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/Http/Request.h>
+#include <Wt/Http/Response.h>
+
+#include "RequestContext.hpp"
+
+namespace API::Subsonic::Stream
+{
+	void handleDownload(RequestContext& context, const Wt::Http::Request& request, Wt::Http::Response& response);
+	void handleStream(RequestContext& context, const Wt::Http::Request& request, Wt::Http::Response& response);
+}
+
@@ -0,0 +1,208 @@
+#include "UserManagement.hpp"
+
+#include "services/database/Session.hpp"
+#include "services/database/User.hpp"
+#include "services/auth/IPasswordService.hpp"
+#include "utils/Service.hpp"
+#include "responses/User.hpp"
+#include "ParameterParsing.hpp"
+#include "Utils.hpp"
+
+namespace API::Subsonic
+{
+    using namespace Database;
+
+    namespace {
+        void checkUserIsMySelfOrAdmin(RequestContext& context, const std::string& username)
+        {
+            User::pointer currentUser{ User::find(context.dbSession, context.userId) };
+            if (!currentUser)
+                throw RequestedDataNotFoundError{};
+
+            if (currentUser->getLoginName() != username && !currentUser->isAdmin())
+                throw UserNotAuthorizedError{};
+        }
+    }
+
+    Response handleGetUserRequest(RequestContext& context)
+    {
+        std::string username{ getMandatoryParameterAs<std::string>(context.parameters, "username") };
+
+        auto transaction{ context.dbSession.createSharedTransaction() };
+
+        checkUserIsMySelfOrAdmin(context, username);
+
+        const User::pointer user{ User::find(context.dbSession, username) };
+        if (!user)
+            throw RequestedDataNotFoundError{};
+
+        Response response{ Response::createOkResponse(context.serverProtocolVersion) };
+        response.addNode("user", createUserNode(user));
+
+        return response;
+    }
+
+    Response handleGetUsersRequest(RequestContext& context)
+    {
+        auto transaction{ context.dbSession.createSharedTransaction() };
+
+        Response response{ Response::createOkResponse(context.serverProtocolVersion) };
+        Response::Node& usersNode{ response.createNode("users") };
+
+        const auto userIds{ User::find(context.dbSession, User::FindParameters {}) };
+        for (const UserId userId : userIds.results)
+        {
+            const User::pointer user{ User::find(context.dbSession, userId) };
+            usersNode.addArrayChild("user", createUserNode(user));
+        }
+
+        return response;
+    }
+
+    Response handleCreateUserRequest(RequestContext& context)
+    {
+        std::string username{ getMandatoryParameterAs<std::string>(context.parameters, "username") };
+        std::string password{ decodePasswordIfNeeded(getMandatoryParameterAs<std::string>(context.parameters, "password")) };
+        // Just ignore all the other fields as we don't handle them
+
+        Database::UserId userId;
+        {
+            auto transaction{ context.dbSession.createUniqueTransaction() };
+
+            User::pointer user{ User::find(context.dbSession, username) };
+            if (user)
+                throw UserAlreadyExistsGenericError{};
+
+            user = context.dbSession.create<User>(username);
+            userId = user->getId();
+        }
+
+        auto removeCreatedUser{ [&]()
+        {
+            auto transaction {context.dbSession.createUniqueTransaction()};
+            User::pointer user {User::find(context.dbSession, userId)};
+            if (user)
+                user.remove();
+        } };
+
+        try
+        {
+            Service<Auth::IPasswordService>::get()->setPassword(userId, password);
+        }
+        catch (const Auth::PasswordMustMatchLoginNameException&)
+        {
+            removeCreatedUser();
+            throw PasswordMustMatchLoginNameGenericError{};
+        }
+        catch (const Auth::PasswordTooWeakException&)
+        {
+            removeCreatedUser();
+            throw PasswordTooWeakGenericError{};
+        }
+        catch (const Auth::Exception& exception)
+        {
+            removeCreatedUser();
+            throw UserNotAuthorizedError{};
+        }
+
+        return Response::createOkResponse(context.serverProtocolVersion);
+    }
+
+    Response handleDeleteUserRequest(RequestContext& context)
+    {
+        std::string username{ getMandatoryParameterAs<std::string>(context.parameters, "username") };
+
+        auto transaction{ context.dbSession.createUniqueTransaction() };
+
+        User::pointer user{ User::find(context.dbSession, username) };
+        if (!user)
+            throw RequestedDataNotFoundError{};
+
+        // cannot delete ourself
+        if (user->getId() == context.userId)
+            throw UserNotAuthorizedError{};
+
+        user.remove();
+
+        return Response::createOkResponse(context.serverProtocolVersion);
+    }
+
+    Response handleUpdateUserRequest(RequestContext& context)
+    {
+        std::string username{ getMandatoryParameterAs<std::string>(context.parameters, "username") };
+        std::optional<std::string> password{ getParameterAs<std::string>(context.parameters, "password") };
+
+        UserId userId;
+        {
+            auto transaction{ context.dbSession.createSharedTransaction() };
+
+            User::pointer user{ User::find(context.dbSession, username) };
+            if (!user)
+                throw RequestedDataNotFoundError{};
+
+            userId = user->getId();
+        }
+
+        if (password)
+        {
+            Utils::checkSetPasswordImplemented();
+
+            try
+            {
+                Service<::Auth::IPasswordService>()->setPassword(userId, decodePasswordIfNeeded(*password));
+            }
+            catch (const Auth::PasswordMustMatchLoginNameException&)
+            {
+                throw PasswordMustMatchLoginNameGenericError{};
+            }
+            catch (const Auth::PasswordTooWeakException&)
+            {
+                throw PasswordTooWeakGenericError{};
+            }
+            catch (const Auth::Exception&)
+            {
+                throw UserNotAuthorizedError{};
+            }
+        }
+
+        return Response::createOkResponse(context.serverProtocolVersion);
+    }
+
+    Response handleChangePassword(RequestContext& context)
+    {
+        std::string username{ getMandatoryParameterAs<std::string>(context.parameters, "username") };
+        std::string password{ decodePasswordIfNeeded(getMandatoryParameterAs<std::string>(context.parameters, "password")) };
+
+        try
+        {
+            Database::UserId userId;
+            {
+                auto transaction{ context.dbSession.createSharedTransaction() };
+
+                checkUserIsMySelfOrAdmin(context, username);
+
+                User::pointer user{ User::find(context.dbSession, username) };
+                if (!user)
+                    throw UserNotAuthorizedError{};
+
+                userId = user->getId();
+            }
+
+            Service<Auth::IPasswordService>::get()->setPassword(userId, password);
+        }
+        catch (const Auth::PasswordMustMatchLoginNameException&)
+        {
+            throw PasswordMustMatchLoginNameGenericError{};
+        }
+        catch (const Auth::PasswordTooWeakException&)
+        {
+            throw PasswordTooWeakGenericError{};
+        }
+        catch (const Auth::Exception& authException)
+        {
+            throw UserNotAuthorizedError{};
+        }
+
+        return Response::createOkResponse(context.serverProtocolVersion);
+    }
+}
@@ -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/>.
+ */
+
+#pragma once
+
+#include "RequestContext.hpp"
+#include "SubsonicResponse.hpp"
+
+namespace API::Subsonic
+{
+    Response handleGetUserRequest(RequestContext& context);
+    Response handleGetUsersRequest(RequestContext& context);
+    Response handleCreateUserRequest(RequestContext& context);
+    Response handleUpdateUserRequest(RequestContext& context);
+    Response handleDeleteUserRequest(RequestContext& context);
+    Response handleChangePassword(RequestContext& context);
+}