From 78f62c8d78b379f83ef42bd8bad0a30b81cf8900 Mon Sep 17 00:00:00 2001
From: Rimma Kubanova <rimma.kubanova@gmail.com>
Date: Thu, 22 Aug 2024 21:53:07 +0500
Subject: [PATCH 1/9] soundcloud export & import

---
 .../src/playlists/components/PlaylistMenu.tsx |  57 ++++-
 frontend/js/src/user/playlists/Playlists.tsx  |  30 ++-
 .../ImportSoundCloudPlaylistModal.tsx         | 203 ++++++++++++++++++
 frontend/js/src/utils/APIService.ts           |  45 ++++
 frontend/js/src/utils/soundcloudTypes.d.ts    |  39 ++++
 frontend/js/src/utils/types.d.ts              |   4 -
 .../metadata_cache/soundcloud/client.py       |  41 ++++
 listenbrainz/troi/export.py                   |  21 ++
 listenbrainz/troi/import_ms.py                |  19 +-
 listenbrainz/webserver/views/playlist_api.py  | 104 ++++++---
 10 files changed, 527 insertions(+), 36 deletions(-)
 create mode 100644 frontend/js/src/user/playlists/components/ImportSoundCloudPlaylistModal.tsx
 create mode 100644 frontend/js/src/utils/soundcloudTypes.d.ts
 create mode 100644 listenbrainz/metadata_cache/soundcloud/client.py

diff --git a/frontend/js/src/playlists/components/PlaylistMenu.tsx b/frontend/js/src/playlists/components/PlaylistMenu.tsx
index 52aa3f2399..b0e00bd9fc 100644
--- a/frontend/js/src/playlists/components/PlaylistMenu.tsx
+++ b/frontend/js/src/playlists/components/PlaylistMenu.tsx
@@ -1,7 +1,7 @@
 /* eslint-disable jsx-a11y/anchor-is-valid */
 /* eslint-disable react/jsx-no-comment-textnodes */
 import { IconProp } from "@fortawesome/fontawesome-svg-core";
-import { faSpotify } from "@fortawesome/free-brands-svg-icons";
+import { faSpotify, faSoundcloud } from "@fortawesome/free-brands-svg-icons";
 import {
   faCopy,
   faFileExport,
@@ -36,7 +36,9 @@ function PlaylistMenu({
   onPlaylistCopied,
   disallowEmptyPlaylistExport,
 }: PlaylistMenuProps) {
-  const { APIService, currentUser, spotifyAuth } = useContext(GlobalAppContext);
+  const { APIService, currentUser, spotifyAuth, soundcloudAuth } = useContext(
+    GlobalAppContext
+  );
   const { auth_token } = currentUser;
   const playlistID = getPlaylistId(playlist);
   const playlistTitle = playlist.title;
@@ -159,6 +161,40 @@ function PlaylistMenu({
       { toastId: "export-playlist" }
     );
   };
+  const exportToSoundcloud = async () => {
+    if (!auth_token) {
+      alertMustBeLoggedIn();
+      return;
+    }
+    let result;
+    if (playlistID) {
+      result = await APIService.exportPlaylistToSoundCloud(
+        auth_token,
+        playlistID
+      );
+    } else {
+      // TODO
+      // result = await APIService.exportJSPFPlaylistToSoundCloud(
+      //   auth_token,
+      //   playlist
+      // );
+    }
+    const { external_url } = result;
+    toast.success(
+      <ToastMsg
+        title="Playlist exported to Soundcloud"
+        message={
+          <>
+            Successfully exported playlist:{" "}
+            <a href={external_url} target="_blank" rel="noopener noreferrer">
+              {playlistTitle}
+            </a>
+          </>
+        }
+      />,
+      { toastId: "export-playlist" }
+    );
+  };
   const handlePlaylistExport = async (handler: () => Promise<void>) => {
     if (!playlist || (disallowEmptyPlaylistExport && !playlist.track.length)) {
       toast.warn(
@@ -179,6 +215,7 @@ function PlaylistMenu({
   const showSpotifyExportButton = spotifyAuth?.permission?.includes(
     "playlist-modify-public"
   );
+  const showSoundCloudExportButton = soundcloudAuth;
   return (
     <ul
       className="dropdown-menu dropdown-menu-right"
@@ -248,6 +285,22 @@ function PlaylistMenu({
           </li>
         </>
       )}
+      {showSoundCloudExportButton && (
+        <>
+          <li role="separator" className="divider" />
+          <li>
+            <a
+              id="exportPlaylistToSoundCloud"
+              role="button"
+              href="#"
+              onClick={() => handlePlaylistExport(exportToSoundcloud)}
+            >
+              <FontAwesomeIcon icon={faSoundcloud as IconProp} /> Export to
+              SoundCloud
+            </a>
+          </li>
+        </>
+      )}
       <li role="separator" className="divider" />
       <li>
         <a
diff --git a/frontend/js/src/user/playlists/Playlists.tsx b/frontend/js/src/user/playlists/Playlists.tsx
index 74fa1f2ffd..4e3c83042c 100644
--- a/frontend/js/src/user/playlists/Playlists.tsx
+++ b/frontend/js/src/user/playlists/Playlists.tsx
@@ -8,7 +8,11 @@ import {
   faFileImport,
   faMusic,
 } from "@fortawesome/free-solid-svg-icons";
-import { faSpotify, faItunesNote } from "@fortawesome/free-brands-svg-icons";
+import {
+  faSpotify,
+  faItunesNote,
+  faSoundcloud,
+} from "@fortawesome/free-brands-svg-icons";
 import * as React from "react";
 
 import NiceModal from "@ebay/nice-modal-react";
@@ -25,6 +29,7 @@ import CreateOrEditPlaylistModal from "../../playlists/components/CreateOrEditPl
 import ImportPlaylistModal from "./components/ImportJSPFPlaylistModal";
 import ImportSpotifyPlaylistModal from "./components/ImportSpotifyPlaylistModal";
 import ImportAppleMusicPlaylistModal from "./components/ImportAppleMusicPlaylistModal";
+import ImportSoundCloudPlaylistModal from "./components/ImportSoundCloudPlaylistModal";
 import PlaylistsList from "./components/PlaylistsList";
 import { getPlaylistId, PlaylistType } from "../../playlists/utils";
 
@@ -222,6 +227,29 @@ export default class UserPlaylists extends React.Component<
                     &nbsp;Apple Music
                   </button>
                 </li>
+                <li>
+                  <button
+                    type="button"
+                    onClick={() => {
+                      NiceModal.show<JSPFPlaylist | JSPFPlaylist[], any>(
+                        ImportSoundCloudPlaylistModal
+                      ).then((playlist) => {
+                        if (Array.isArray(playlist)) {
+                          playlist.forEach((p: JSPFPlaylist) => {
+                            this.onPlaylistCreated(p);
+                          });
+                        } else {
+                          this.onPlaylistCreated(playlist);
+                        }
+                      });
+                    }}
+                    data-toggle="modal"
+                    data-target="#ImportMusicServicePlaylistModal"
+                  >
+                    <FontAwesomeIcon icon={faSoundcloud} />
+                    &nbsp;SoundCloud
+                  </button>
+                </li>
                 <li>
                   <button
                     type="button"
diff --git a/frontend/js/src/user/playlists/components/ImportSoundCloudPlaylistModal.tsx b/frontend/js/src/user/playlists/components/ImportSoundCloudPlaylistModal.tsx
new file mode 100644
index 0000000000..bc456e15d4
--- /dev/null
+++ b/frontend/js/src/user/playlists/components/ImportSoundCloudPlaylistModal.tsx
@@ -0,0 +1,203 @@
+import React from "react";
+import NiceModal, { useModal } from "@ebay/nice-modal-react";
+import { toast } from "react-toastify";
+import { Link } from "react-router-dom";
+import GlobalAppContext from "../../../utils/GlobalAppContext";
+import { ToastMsg } from "../../../notifications/Notifications";
+import Loader from "../../../components/Loader";
+
+type ImportPLaylistModalProps = {
+  listenlist: JSPFTrack[];
+};
+
+export default NiceModal.create((props: ImportPLaylistModalProps) => {
+  const modal = useModal();
+
+  const closeModal = React.useCallback(() => {
+    modal.hide();
+    document?.body?.classList?.remove("modal-open");
+    setTimeout(modal.remove, 200);
+  }, [modal]);
+
+  const { APIService, currentUser } = React.useContext(GlobalAppContext);
+  const [playlists, setPlaylists] = React.useState<SoundCloudPlaylistObject[]>(
+    []
+  );
+  const [newPlaylists, setNewPlaylists] = React.useState<JSPFPlaylist[]>([]);
+  const [playlistLoading, setPlaylistLoading] = React.useState<string | null>(
+    null
+  );
+
+  React.useEffect(() => {
+    async function getUserSoundcloudPlaylists() {
+      try {
+        const response = await APIService.importPlaylistFromSoundCloud(
+          currentUser?.auth_token
+        );
+
+        if (!response) {
+          return;
+        }
+
+        setPlaylists(response);
+      } catch (error) {
+        toast.error(
+          <ToastMsg
+            title="Error loading playlists"
+            message={
+              error?.message === "Forbidden" ? (
+                <>
+                  Session has expired. Please reconnect to{" "}
+                  <Link to="/settings/music-services/details/">Soundcloud</Link>
+                  .
+                </>
+              ) : (
+                error?.message ?? error
+              )
+            }
+          />,
+          { toastId: "load-playlists-error" }
+        );
+      }
+    }
+
+    if (currentUser?.auth_token) {
+      getUserSoundcloudPlaylists();
+    }
+  }, [APIService, currentUser]);
+
+  const resolveAndClose = () => {
+    modal.resolve(newPlaylists);
+    closeModal();
+  };
+
+  const alertMustBeLoggedIn = () => {
+    toast.error(
+      <ToastMsg
+        title="Error"
+        message="You must be logged in for this operation"
+      />,
+      { toastId: "auth-error" }
+    );
+  };
+
+  const importTracksToPlaylist = async (
+    playlistID: string,
+    playlistName: string
+  ) => {
+    if (!currentUser?.auth_token) {
+      alertMustBeLoggedIn();
+      return;
+    }
+    setPlaylistLoading(playlistName);
+    try {
+      const newPlaylist: JSPFPlaylist = await APIService.importSoundCloudPlaylistTracks(
+        currentUser?.auth_token,
+        playlistID
+      );
+      toast.success(
+        <ToastMsg
+          title="Successfully imported playlist from Soundcloud"
+          message={
+            <>
+              Imported
+              <a href={newPlaylist.identifier}> {playlistName}</a>
+            </>
+          }
+        />,
+        { toastId: "create-playlist-success" }
+      );
+      setNewPlaylists([...newPlaylists, newPlaylist]);
+    } catch (error) {
+      toast.error(
+        <ToastMsg
+          title="Something went wrong"
+          message={<>We could not save your playlist: {error.toString()}</>}
+        />,
+        { toastId: "save-playlist-error" }
+      );
+    }
+    setPlaylistLoading(null);
+  };
+
+  return (
+    <div
+      className={`modal fade ${modal.visible ? "in" : ""}`}
+      id="ImportMusicServicePlaylistModal"
+      tabIndex={-1}
+      role="dialog"
+      aria-labelledby="ImportMusicServicePlaylistLabel"
+      data-backdrop="static"
+    >
+      <div className="modal-dialog" role="document">
+        <div className="modal-content">
+          <div className="modal-header">
+            <button
+              type="button"
+              className="close"
+              data-dismiss="modal"
+              aria-label="Close"
+              onClick={resolveAndClose}
+            >
+              <span aria-hidden="true">&times;</span>
+            </button>
+            <h4
+              className="modal-title"
+              id="ImportMusicServicePlaylistLabel"
+              style={{ textAlign: "center" }}
+            >
+              Import playlist from SoundCloud
+            </h4>
+          </div>
+          <div className="modal-body">
+            <p className="text-muted">
+              Add one or more of your SoundCloud playlists below:
+            </p>
+            <div
+              className="list-group"
+              style={{ maxHeight: "50vh", overflow: "scroll" }}
+            >
+              {playlists?.map((playlist: SoundCloudPlaylistObject) => (
+                <button
+                  type="button"
+                  key={playlist.id}
+                  className="list-group-item"
+                  style={{
+                    display: "flex",
+                    justifyContent: "space-between",
+                  }}
+                  disabled={!!playlistLoading}
+                  name={playlist.title}
+                  onClick={() =>
+                    importTracksToPlaylist(playlist.id, playlist.title)
+                  }
+                >
+                  <span>{playlist.title}</span>
+                </button>
+              ))}
+            </div>
+            {!!playlistLoading && (
+              <div>
+                <p>
+                  Loading playlist {playlistLoading}... It might take some time
+                </p>
+                <Loader isLoading={!!playlistLoading} />
+              </div>
+            )}
+          </div>
+
+          <div className="modal-footer">
+            <button
+              type="button"
+              className="btn btn-default"
+              data-dismiss="modal"
+              onClick={resolveAndClose}
+            >
+              Close
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+});
diff --git a/frontend/js/src/utils/APIService.ts b/frontend/js/src/utils/APIService.ts
index 74d676be13..a93744fc8b 100644
--- a/frontend/js/src/utils/APIService.ts
+++ b/frontend/js/src/utils/APIService.ts
@@ -1175,6 +1175,19 @@ export default class APIService {
     return response.json();
   };
 
+  importPlaylistFromSoundCloud = async (userToken?: string): Promise<any> => {
+    const url = `${this.APIBaseURI}/playlist/import/soundcloud`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Token ${userToken}`,
+        "Content-Type": "application/json;charset=UTF-8",
+      },
+    });
+    await this.checkStatus(response);
+    return response.json();
+  };
+
   importSpotifyPlaylistTracks = async (
     userToken: string,
     playlistID: string
@@ -1207,6 +1220,22 @@ export default class APIService {
     return response.json();
   };
 
+  importSoundCloudPlaylistTracks = async (
+    userToken: string,
+    playlistID: string
+  ): Promise<any> => {
+    const url = `${this.APIBaseURI}/playlist/soundcloud/${playlistID}/tracks`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Token ${userToken}`,
+        "Content-Type": "application/json;charset=UTF-8",
+      },
+    });
+    await this.checkStatus(response);
+    return response.json();
+  };
+
   lookupMBRecording = async (
     recordingMBID: string,
     inc = "artists"
@@ -1491,6 +1520,22 @@ export default class APIService {
     return response.json();
   };
 
+  exportPlaylistToSoundCloud = async (
+    userToken: string,
+    playlist_mbid: string
+  ): Promise<any> => {
+    const url = `${this.APIBaseURI}/playlist/${playlist_mbid}/export/soundcloud`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Token ${userToken}`,
+        "Content-Type": "application/json;charset=UTF-8",
+      },
+    });
+    await this.checkStatus(response);
+    return response.json();
+  };
+
   exportPlaylistToXSPF = async (
     userToken: string,
     playlist_mbid: string
diff --git a/frontend/js/src/utils/soundcloudTypes.d.ts b/frontend/js/src/utils/soundcloudTypes.d.ts
new file mode 100644
index 0000000000..6c246d1d94
--- /dev/null
+++ b/frontend/js/src/utils/soundcloudTypes.d.ts
@@ -0,0 +1,39 @@
+declare type SoundCloudUser = {
+    access_token?: string;
+  };
+
+declare type SoundCloudTrackObject = {
+    id: string;
+    permalink_url: string;
+    artwork_url?: string;
+    title: string;
+    uri: string;
+    duration: number;
+    user: {
+      id: string;
+      username: string;
+      avatar_url?: string;
+    };
+};
+
+declare type SoundCloudPlaylistObject = {
+    id: string;
+    title: string;
+    description?: string;
+    tracks: SoundCloudTrackObject[];
+    created_at: string;
+    duration: number;
+    artwork_url?: string;
+    genre?: string;
+    user: {
+      id: number;
+      username: string;
+      avatar_url?: string; 
+    };
+};
+
+declare type SoundcloudAPIError = {
+    code: integer;
+    message: string;
+    link: string;
+};
diff --git a/frontend/js/src/utils/types.d.ts b/frontend/js/src/utils/types.d.ts
index 7d1b3bb571..8f14c331cc 100644
--- a/frontend/js/src/utils/types.d.ts
+++ b/frontend/js/src/utils/types.d.ts
@@ -90,10 +90,6 @@ declare type YoutubeUser = {
   api_key?: string;
 };
 
-declare type SoundCloudUser = {
-  access_token?: string;
-};
-
 declare type MetaBrainzProjectUser = {
   access_token?: string;
 };
diff --git a/listenbrainz/metadata_cache/soundcloud/client.py b/listenbrainz/metadata_cache/soundcloud/client.py
new file mode 100644
index 0000000000..319a6f7eac
--- /dev/null
+++ b/listenbrainz/metadata_cache/soundcloud/client.py
@@ -0,0 +1,41 @@
+import requests
+from requests import RequestException
+from requests.adapters import HTTPAdapter
+from urllib3 import Retry
+
+from listenbrainz.domain.soundcloud import SoundCloudService
+from listenbrainz.webserver.errors import APIForbidden
+
+SOUNDCLOUD_URL='https://api.soundcloud.com'
+
+class SoundCloud:
+
+    def __init__(self, token):
+        self.developer_token = token
+        self.retries = 5
+
+    def _get_requests_session(self):
+        retry_strategy = Retry(
+            total=3,
+            status_forcelist=[429, 500, 502, 503, 504],
+            method_whitelist=["HEAD", "GET", "OPTIONS"]
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        http = requests.Session()
+
+        def _assert_status_hook(r, *args, **kwargs):
+            r.raise_for_status()
+
+        http.hooks["response"] = [_assert_status_hook]
+        http.mount("https://", adapter)
+        http.mount("http://", adapter)
+        return http
+
+    def get(self, url, params=None):
+        with self._get_requests_session() as http:
+            for _ in range(self.retries):
+                response = http.get(url, params=params, headers={"Authorization": f"OAuth {self.developer_token}"})
+                if response.status_code == 200:
+                    return response.json()
+
+            response.raise_for_status()
diff --git a/listenbrainz/troi/export.py b/listenbrainz/troi/export.py
index b916742ba3..1dd7327fce 100644
--- a/listenbrainz/troi/export.py
+++ b/listenbrainz/troi/export.py
@@ -1,5 +1,6 @@
 import spotipy
 from troi.patches.playlist_from_listenbrainz import TransferPlaylistPatch
+from listenbrainz.metadata_cache.soundcloud.client import SoundCloud
 
 def export_to_spotify(lb_token, spotify_token, is_public, playlist_mbid=None, jspf=None):
     sp = spotipy.Spotify(auth=spotify_token)
@@ -23,3 +24,23 @@ def export_to_spotify(lb_token, spotify_token, is_public, playlist_mbid=None, js
     playlist = patch.generate_playlist()
     metadata = playlist.playlists[0].additional_metadata
     return metadata["external_urls"]["spotify"]
+
+def export_to_soundcloud(lb_token, soundcloud_token, is_public, playlist_mbid=None, jspf=None):
+    soundcloud_user_id = SoundCloud(soundcloud_token).get("https://api.soundcloud.com/me/")["id"]
+    args = {
+        "mbid": playlist_mbid,
+        "jspf": jspf,
+        "read_only_token": lb_token,
+        "soundcloud": {
+            "user_id": soundcloud_user_id,
+            "token": soundcloud_token,
+            "is_public": is_public,
+        },
+        "upload": True,
+        "echo": False,
+        "min_recordings": 1
+    }
+    patch = TransferPlaylistPatch(args)
+    playlist = patch.generate_playlist()
+    metadata = playlist.playlists[0].additional_metadata
+    return metadata["external_urls"]["soundcloud"]
diff --git a/listenbrainz/troi/import_ms.py b/listenbrainz/troi/import_ms.py
index 290ce8740d..76603dce1f 100644
--- a/listenbrainz/troi/import_ms.py
+++ b/listenbrainz/troi/import_ms.py
@@ -18,7 +18,6 @@ def import_from_spotify(token, user, playlist_id):
     result.update({"identifier": playlist.playlists[0].mbid})
     return result
 
-
 def import_from_apple_music(token, apple_user_token, user, playlist_id):
     args = {
         "ms_token": token,
@@ -37,3 +36,21 @@ def import_from_apple_music(token, apple_user_token, user, playlist_id):
     result.update({'identifier': playlist.playlists[0].mbid})
 
     return result
+
+def import_from_soundcloud(token, user, playlist_id):
+    args = {
+        "ms_token": token,
+        "token": user,
+        "playlist_id": playlist_id,
+        "music_service": 'soundcloud',
+        "apple_user_token": "",
+        "upload": True,
+        "created_for": None,
+        "echo": False,
+        "min_recordings": 1
+    }
+    patch = ImportPlaylistPatch(args)
+    playlist = patch.generate_playlist()
+    result = playlist.get_jspf()
+    result.update({"identifier": playlist.playlists[0].mbid})
+    return result
diff --git a/listenbrainz/webserver/views/playlist_api.py b/listenbrainz/webserver/views/playlist_api.py
index e966d3b5fa..83223ef456 100644
--- a/listenbrainz/webserver/views/playlist_api.py
+++ b/listenbrainz/webserver/views/playlist_api.py
@@ -12,11 +12,12 @@
 import listenbrainz.db.user as db_user
 from listenbrainz.domain.spotify import SpotifyService, SPOTIFY_PLAYLIST_PERMISSIONS
 from listenbrainz.domain.apple import AppleService
-from listenbrainz.troi.export import export_to_spotify
-from listenbrainz.troi.import_ms import import_from_spotify, import_from_apple_music
+from listenbrainz.domain.soundcloud import SoundCloudService
+from listenbrainz.troi.export import export_to_spotify, export_to_soundcloud
+from listenbrainz.troi.import_ms import import_from_spotify, import_from_apple_music, import_from_soundcloud
 from listenbrainz.webserver import db_conn, ts_conn
 from listenbrainz.metadata_cache.apple.client import Apple
-
+from listenbrainz.metadata_cache.soundcloud.client import SoundCloud
 from listenbrainz.webserver.utils import parse_boolean_arg
 from listenbrainz.webserver.decorators import crossdomain, api_listenstore_needed
 from listenbrainz.webserver.errors import APIBadRequest, APIInternalServerError, APINotFound, APIForbidden, APIError, PlaylistAPIXMLError, APIUnauthorized
@@ -860,22 +861,30 @@ def export_playlist(playlist_mbid, service):
     if not is_valid_uuid(playlist_mbid):
         log_raise_400("Provided playlist ID is invalid.")
 
-    if service != "spotify":
+    if service != "spotify" and service != "soundcloud":
         raise APIBadRequest(f"Service {service} is not supported. We currently only support 'spotify'.")
 
-    spotify_service = SpotifyService()
-    token = spotify_service.get_user(user["id"], refresh=True)
+    if service == "spotify":
+        spotify_service = SpotifyService()
+        token = spotify_service.get_user(user["id"], refresh=True)
+    elif service == "soundcloud":
+        soundcloud_service = SoundCloudService()
+        token = soundcloud_service.get_user(user["id"])
+
     if not token:
         raise APIBadRequest(f"Service {service} is not linked. Please link your {service} account first.")
 
-    if not SPOTIFY_PLAYLIST_PERMISSIONS.issubset(set(token["scopes"])):
+    if service=='spotify' and not SPOTIFY_PLAYLIST_PERMISSIONS.issubset(set(token["scopes"])):
         raise APIBadRequest(f"Missing scopes playlist-modify-public and playlist-modify-private to export playlists."
                             f" Please relink your {service} account from ListenBrainz settings with appropriate scopes"
                             f" to use this feature.")
 
     is_public = parse_boolean_arg("is_public", True)
     try:
-        url = export_to_spotify(user["auth_token"], token["access_token"], is_public, playlist_mbid=playlist_mbid)
+        if service == "spotify":
+            url = export_to_spotify(user["auth_token"], token["access_token"], is_public, playlist_mbid=playlist_mbid)
+        else:
+            url = export_to_soundcloud(user["auth_token"], token["access_token"], is_public, playlist_mbid=playlist_mbid)
         return jsonify({"external_url": url})
     except requests.exceptions.HTTPError as exc:
         error = exc.response.json()
@@ -888,9 +897,7 @@ def export_playlist(playlist_mbid, service):
 @api_listenstore_needed
 def import_playlist_from_music_service(service):
     """
-
     Get playlists from chosen Music Service.
-
     :reqheader Authorization: Token <user token>
     :statuscode 200: playlists are fetched.
     :statuscode 401: invalid authorization. See error message for details.
@@ -898,24 +905,28 @@ def import_playlist_from_music_service(service):
     :resheader Content-Type: *application/json*
     """
     user = validate_auth_header()
-
-    if service != "apple_music" and service != "spotify":
-        raise APIBadRequest(f"Service {service} is not supported. We currently only support 'spotify'.")
-
+    
+    supported_services = {
+        "spotify": SpotifyService,
+        "apple_music": AppleService,
+        "soundcloud": SoundCloudService
+    }
+    
+    if service not in supported_services:
+        raise APIBadRequest(f"Service '{service}' is not supported. Supported services are: 'spotify', 'apple_music', 'soundcloud'.")
+
+    service_class = supported_services[service]()
     if service == "spotify":
-        spotify_service = SpotifyService()
-        token = spotify_service.get_user(user["id"], refresh=True)
-    elif service == "apple_music":
-        apple_service = AppleService()
-        # TODO: implement refresh token for AppleMusic
-        token = apple_service.get_user(user["id"])
+        token = service_class.get_user(user["id"], refresh=True)
+    else:
+        token = service_class.get_user(user["id"])
 
     if not token:
         raise APIBadRequest(f"Service {service} is not linked. Please link your {service} account first.")
-
-    if service == "apple_music" and not token["refresh_token"]:
+    
+    if service == "apple_music" and not token.get("refresh_token"):
         raise APIBadRequest("Not authorized to Apple Music. Please link your account first.")
-
+    
     if service == "spotify" and not SPOTIFY_PLAYLIST_PERMISSIONS.issubset(set(token["scopes"])):
         raise APIBadRequest(f"Missing scopes playlist-modify-public and playlist-modify-private to export playlists."
                             f" Please relink your {service} account from ListenBrainz settings with appropriate scopes"
@@ -923,12 +934,20 @@ def import_playlist_from_music_service(service):
 
     try:
         if service == "spotify":
-            sp = spotipy.Spotify(token["access_token"])
-            playlists = sp.current_user_playlists()
+            spotify = spotipy.Spotify(auth=token["access_token"])
+            playlists = spotify.current_user_playlists()
             return jsonify(playlists["items"])
-        else:
-            apple = Apple().get_user_data("https://api.music.apple.com/v1/me/library/playlists/", token["refresh_token"])
-            return jsonify(apple["data"])
+
+        elif service == "apple_music":
+            apple = Apple()
+            playlists = apple.get_user_data("https://api.music.apple.com/v1/me/library/playlists/", token["refresh_token"])
+            return jsonify(playlists.get("data", []))
+
+        elif service == "soundcloud":
+            soundcloud = SoundCloud(token["access_token"])
+            playlists = soundcloud.get("https://api.soundcloud.com/me/playlists/")
+            return jsonify(playlists)
+
     except requests.exceptions.HTTPError as exc:
         error = exc.response.json()
         raise APIError(error.get("error") or exc.response.reason, exc.response.status_code)
@@ -1006,6 +1025,35 @@ def import_tracks_from_apple_playlist(playlist_id):
         raise APIError(error.get("error") or exc.response.reason, exc.response.status_code)
 
 
+@playlist_api_bp.route("/soundcloud/<playlist_id>/tracks", methods=["GET", "OPTIONS"])
+@crossdomain
+@ratelimit()
+@api_listenstore_needed
+def import_tracks_from_soundcloud_playlist(playlist_id):
+    """
+    Import a playlist tracks from a SoundCloud and convert them to JSPF.
+    :reqheader Authorization: Token <user token>
+    :param playlist_id: The SoundCloud playlist id to get the tracks from
+    :statuscode 200: tracks are fetched and converted.
+    :statuscode 401: invalid authorization. See error message for details.
+    :statuscode 404: Playlist not found
+    :resheader Content-Type: *application/json*
+    """
+    user = validate_auth_header()
+
+    soundcloud_service = SoundCloudService()
+    token = soundcloud_service.get_user(user["id"])
+    if not token:
+        raise APIBadRequest(f"Service SoundCloud is not linked. Please link your SoundCloud account first.")
+
+    try:
+        playlist = import_from_soundcloud(token["access_token"], user["auth_token"], playlist_id)
+        return playlist
+    except requests.exceptions.HTTPError as exc:
+        error = exc.response.json()
+        raise APIError(error.get("error") or exc.response.reason, exc.response.status_code)
+
+
 @playlist_api_bp.route("/export-jspf/<service>", methods=["POST", "OPTIONS"])
 @crossdomain
 @ratelimit()

From d16f6f4d45ed9702375219fb671adce249e9b90a Mon Sep 17 00:00:00 2001
From: Rimma Kubanova <rimma.kubanova@gmail.com>
Date: Thu, 22 Aug 2024 22:03:32 +0500
Subject: [PATCH 2/9] fixed pep8speaks && removed line between spotify and sc

---
 .../src/playlists/components/PlaylistMenu.tsx | 39 ++++++++++++-------
 .../metadata_cache/soundcloud/client.py       |  3 +-
 listenbrainz/troi/export.py                   |  1 +
 listenbrainz/troi/import_ms.py                |  1 +
 listenbrainz/webserver/views/playlist_api.py  | 13 ++++---
 5 files changed, 36 insertions(+), 21 deletions(-)

diff --git a/frontend/js/src/playlists/components/PlaylistMenu.tsx b/frontend/js/src/playlists/components/PlaylistMenu.tsx
index b0e00bd9fc..3a850eac60 100644
--- a/frontend/js/src/playlists/components/PlaylistMenu.tsx
+++ b/frontend/js/src/playlists/components/PlaylistMenu.tsx
@@ -270,22 +270,33 @@ function PlaylistMenu({
           </li>
         </>
       )}
+      <li role="separator" className="divider" />
       {showSpotifyExportButton && (
-        <>
-          <li role="separator" className="divider" />
-          <li>
-            <a
-              id="exportPlaylistToSpotify"
-              role="button"
-              href="#"
-              onClick={() => handlePlaylistExport(exportToSpotify)}
-            >
-              <FontAwesomeIcon icon={faSpotify as IconProp} /> Export to Spotify
-            </a>
-          </li>
-        </>
+        <li>
+          <a
+            id="exportPlaylistToSpotify"
+            role="button"
+            href="#"
+            onClick={() => handlePlaylistExport(exportToSpotify)}
+          >
+            <FontAwesomeIcon icon={faSpotify as IconProp} /> Export to Spotify
+          </a>
+        </li>
       )}
       {showSoundCloudExportButton && (
+        <li>
+          <a
+            id="exportPlaylistToSoundCloud"
+            role="button"
+            href="#"
+            onClick={() => handlePlaylistExport(exportToSoundcloud)}
+          >
+            <FontAwesomeIcon icon={faSoundcloud as IconProp} /> Export to
+            SoundCloud
+          </a>
+        </li>
+      )}
+      {/* {showSoundCloudExportButton && (
         <>
           <li role="separator" className="divider" />
           <li>
@@ -300,7 +311,7 @@ function PlaylistMenu({
             </a>
           </li>
         </>
-      )}
+      )} */}
       <li role="separator" className="divider" />
       <li>
         <a
diff --git a/listenbrainz/metadata_cache/soundcloud/client.py b/listenbrainz/metadata_cache/soundcloud/client.py
index 319a6f7eac..9a8557bfc9 100644
--- a/listenbrainz/metadata_cache/soundcloud/client.py
+++ b/listenbrainz/metadata_cache/soundcloud/client.py
@@ -6,7 +6,8 @@
 from listenbrainz.domain.soundcloud import SoundCloudService
 from listenbrainz.webserver.errors import APIForbidden
 
-SOUNDCLOUD_URL='https://api.soundcloud.com'
+SOUNDCLOUD_URL = 'https://api.soundcloud.com'
+
 
 class SoundCloud:
 
diff --git a/listenbrainz/troi/export.py b/listenbrainz/troi/export.py
index 1dd7327fce..f9db0b8d56 100644
--- a/listenbrainz/troi/export.py
+++ b/listenbrainz/troi/export.py
@@ -25,6 +25,7 @@ def export_to_spotify(lb_token, spotify_token, is_public, playlist_mbid=None, js
     metadata = playlist.playlists[0].additional_metadata
     return metadata["external_urls"]["spotify"]
 
+
 def export_to_soundcloud(lb_token, soundcloud_token, is_public, playlist_mbid=None, jspf=None):
     soundcloud_user_id = SoundCloud(soundcloud_token).get("https://api.soundcloud.com/me/")["id"]
     args = {
diff --git a/listenbrainz/troi/import_ms.py b/listenbrainz/troi/import_ms.py
index 76603dce1f..193b654bb8 100644
--- a/listenbrainz/troi/import_ms.py
+++ b/listenbrainz/troi/import_ms.py
@@ -37,6 +37,7 @@ def import_from_apple_music(token, apple_user_token, user, playlist_id):
 
     return result
 
+
 def import_from_soundcloud(token, user, playlist_id):
     args = {
         "ms_token": token,
diff --git a/listenbrainz/webserver/views/playlist_api.py b/listenbrainz/webserver/views/playlist_api.py
index 83223ef456..18defacc7f 100644
--- a/listenbrainz/webserver/views/playlist_api.py
+++ b/listenbrainz/webserver/views/playlist_api.py
@@ -874,7 +874,7 @@ def export_playlist(playlist_mbid, service):
     if not token:
         raise APIBadRequest(f"Service {service} is not linked. Please link your {service} account first.")
 
-    if service=='spotify' and not SPOTIFY_PLAYLIST_PERMISSIONS.issubset(set(token["scopes"])):
+    if service == 'spotify' and not SPOTIFY_PLAYLIST_PERMISSIONS.issubset(set(token["scopes"])):
         raise APIBadRequest(f"Missing scopes playlist-modify-public and playlist-modify-private to export playlists."
                             f" Please relink your {service} account from ListenBrainz settings with appropriate scopes"
                             f" to use this feature.")
@@ -905,15 +905,16 @@ def import_playlist_from_music_service(service):
     :resheader Content-Type: *application/json*
     """
     user = validate_auth_header()
-    
+
     supported_services = {
         "spotify": SpotifyService,
         "apple_music": AppleService,
         "soundcloud": SoundCloudService
     }
-    
+
     if service not in supported_services:
-        raise APIBadRequest(f"Service '{service}' is not supported. Supported services are: 'spotify', 'apple_music', 'soundcloud'.")
+        raise APIBadRequest(f"Service '{service}' is not supported. 
+                            Supported services are: 'spotify', 'apple_music', 'soundcloud'.")
 
     service_class = supported_services[service]()
     if service == "spotify":
@@ -923,10 +924,10 @@ def import_playlist_from_music_service(service):
 
     if not token:
         raise APIBadRequest(f"Service {service} is not linked. Please link your {service} account first.")
-    
+
     if service == "apple_music" and not token.get("refresh_token"):
         raise APIBadRequest("Not authorized to Apple Music. Please link your account first.")
-    
+
     if service == "spotify" and not SPOTIFY_PLAYLIST_PERMISSIONS.issubset(set(token["scopes"])):
         raise APIBadRequest(f"Missing scopes playlist-modify-public and playlist-modify-private to export playlists."
                             f" Please relink your {service} account from ListenBrainz settings with appropriate scopes"

From 66ab5e6ff84cd4213fe49fcc66c98daa765bfbdb Mon Sep 17 00:00:00 2001
From: Rimma Kubanova <rimma.kubanova@gmail.com>
Date: Thu, 22 Aug 2024 22:10:38 +0500
Subject: [PATCH 3/9] fixed typo

---
 listenbrainz/webserver/views/playlist_api.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/listenbrainz/webserver/views/playlist_api.py b/listenbrainz/webserver/views/playlist_api.py
index 18defacc7f..5af4575441 100644
--- a/listenbrainz/webserver/views/playlist_api.py
+++ b/listenbrainz/webserver/views/playlist_api.py
@@ -913,8 +913,8 @@ def import_playlist_from_music_service(service):
     }
 
     if service not in supported_services:
-        raise APIBadRequest(f"Service '{service}' is not supported. 
-                            Supported services are: 'spotify', 'apple_music', 'soundcloud'.")
+        raise APIBadRequest(f"Service '{service}' is not supported."
+                            f" Supported services are: 'spotify', 'apple_music', 'soundcloud'.")
 
     service_class = supported_services[service]()
     if service == "spotify":

From 4479eeba70727dec7cac8c2c41d6252984dd484e Mon Sep 17 00:00:00 2001
From: Rimma Kubanova <rimma.kubanova@gmail.com>
Date: Thu, 22 Aug 2024 22:22:39 +0500
Subject: [PATCH 4/9] fixed typo

---
 listenbrainz/webserver/views/playlist_api.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/listenbrainz/webserver/views/playlist_api.py b/listenbrainz/webserver/views/playlist_api.py
index 5af4575441..a4303254f2 100644
--- a/listenbrainz/webserver/views/playlist_api.py
+++ b/listenbrainz/webserver/views/playlist_api.py
@@ -913,8 +913,8 @@ def import_playlist_from_music_service(service):
     }
 
     if service not in supported_services:
-        raise APIBadRequest(f"Service '{service}' is not supported."
-                            f" Supported services are: 'spotify', 'apple_music', 'soundcloud'.")
+        raise APIBadRequest(f"Service {service} is not supported. "
+                            f"Supported services are: 'spotify', 'apple_music', 'soundcloud'.")
 
     service_class = supported_services[service]()
     if service == "spotify":

From 9734607ecd5e8d7b75c068f35a83f4f2498152ff Mon Sep 17 00:00:00 2001
From: Rimma Kubanova <rimma.kubanova@gmail.com>
Date: Fri, 23 Aug 2024 15:09:10 +0500
Subject: [PATCH 5/9] added export jspf playlist to soundcloud

---
 .../src/playlists/components/PlaylistMenu.tsx |   9 +-
 frontend/js/src/utils/APIService.ts           |  20 +++
 listenbrainz/webserver/views/playlist_api.py  | 124 ++++++++++--------
 3 files changed, 90 insertions(+), 63 deletions(-)

diff --git a/frontend/js/src/playlists/components/PlaylistMenu.tsx b/frontend/js/src/playlists/components/PlaylistMenu.tsx
index 3a850eac60..27c56da4b5 100644
--- a/frontend/js/src/playlists/components/PlaylistMenu.tsx
+++ b/frontend/js/src/playlists/components/PlaylistMenu.tsx
@@ -173,11 +173,10 @@ function PlaylistMenu({
         playlistID
       );
     } else {
-      // TODO
-      // result = await APIService.exportJSPFPlaylistToSoundCloud(
-      //   auth_token,
-      //   playlist
-      // );
+      result = await APIService.exportJSPFPlaylistToSoundCloud(
+        auth_token,
+        playlist
+      );
     }
     const { external_url } = result;
     toast.success(
diff --git a/frontend/js/src/utils/APIService.ts b/frontend/js/src/utils/APIService.ts
index a93744fc8b..f2d7819057 100644
--- a/frontend/js/src/utils/APIService.ts
+++ b/frontend/js/src/utils/APIService.ts
@@ -1536,6 +1536,26 @@ export default class APIService {
     return response.json();
   };
 
+  exportJSPFPlaylistToSoundCloud = async (
+    userToken: string,
+    playlist: JSPFPlaylist
+  ): Promise<any> => {
+    if (!playlist) {
+      throw new Error("Expected a playlist");
+    }
+    const url = `${this.APIBaseURI}/playlist/export-jspf/soundcloud`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Token ${userToken}`,
+        "Content-Type": "application/json;charset=UTF-8",
+      },
+      body: JSON.stringify(playlist),
+    });
+    await this.checkStatus(response);
+    return response.json();
+  };
+
   exportPlaylistToXSPF = async (
     userToken: string,
     playlist_mbid: string
diff --git a/listenbrainz/webserver/views/playlist_api.py b/listenbrainz/webserver/views/playlist_api.py
index a4303254f2..68e1a163a3 100644
--- a/listenbrainz/webserver/views/playlist_api.py
+++ b/listenbrainz/webserver/views/playlist_api.py
@@ -839,58 +839,6 @@ def copy_playlist(playlist_mbid):
     return jsonify({'status': 'ok', 'playlist_mbid': new_playlist.mbid})
 
 
-@playlist_api_bp.route("/<playlist_mbid>/export/<service>", methods=["POST", "OPTIONS"])
-@crossdomain
-@ratelimit()
-@api_listenstore_needed
-def export_playlist(playlist_mbid, service):
-    """
-
-    Export a playlist to an external service, given a playlist MBID. 
-
-    :reqheader Authorization: Token <user token>
-    :param playlist_mbid: The playlist mbid to export.
-    :param is_public: Should the exported playlist be public or not?
-    :statuscode 200: playlist copied.
-    :statuscode 401: invalid authorization. See error message for details.
-    :statuscode 404: Playlist not found
-    :resheader Content-Type: *application/json*
-    """
-    user = validate_auth_header()
-
-    if not is_valid_uuid(playlist_mbid):
-        log_raise_400("Provided playlist ID is invalid.")
-
-    if service != "spotify" and service != "soundcloud":
-        raise APIBadRequest(f"Service {service} is not supported. We currently only support 'spotify'.")
-
-    if service == "spotify":
-        spotify_service = SpotifyService()
-        token = spotify_service.get_user(user["id"], refresh=True)
-    elif service == "soundcloud":
-        soundcloud_service = SoundCloudService()
-        token = soundcloud_service.get_user(user["id"])
-
-    if not token:
-        raise APIBadRequest(f"Service {service} is not linked. Please link your {service} account first.")
-
-    if service == 'spotify' and not SPOTIFY_PLAYLIST_PERMISSIONS.issubset(set(token["scopes"])):
-        raise APIBadRequest(f"Missing scopes playlist-modify-public and playlist-modify-private to export playlists."
-                            f" Please relink your {service} account from ListenBrainz settings with appropriate scopes"
-                            f" to use this feature.")
-
-    is_public = parse_boolean_arg("is_public", True)
-    try:
-        if service == "spotify":
-            url = export_to_spotify(user["auth_token"], token["access_token"], is_public, playlist_mbid=playlist_mbid)
-        else:
-            url = export_to_soundcloud(user["auth_token"], token["access_token"], is_public, playlist_mbid=playlist_mbid)
-        return jsonify({"external_url": url})
-    except requests.exceptions.HTTPError as exc:
-        error = exc.response.json()
-        raise APIError(error.get("error") or exc.response.reason, exc.response.status_code)
-
-
 @playlist_api_bp.route("/import/<service>", methods=["GET", "OPTIONS"])
 @crossdomain
 @ratelimit()
@@ -1055,6 +1003,58 @@ def import_tracks_from_soundcloud_playlist(playlist_id):
         raise APIError(error.get("error") or exc.response.reason, exc.response.status_code)
 
 
+@playlist_api_bp.route("/<playlist_mbid>/export/<service>", methods=["POST", "OPTIONS"])
+@crossdomain
+@ratelimit()
+@api_listenstore_needed
+def export_playlist(playlist_mbid, service):
+    """
+
+    Export a playlist to an external service, given a playlist MBID. 
+
+    :reqheader Authorization: Token <user token>
+    :param playlist_mbid: The playlist mbid to export.
+    :param is_public: Should the exported playlist be public or not?
+    :statuscode 200: playlist copied.
+    :statuscode 401: invalid authorization. See error message for details.
+    :statuscode 404: Playlist not found
+    :resheader Content-Type: *application/json*
+    """
+    user = validate_auth_header()
+
+    if not is_valid_uuid(playlist_mbid):
+        log_raise_400("Provided playlist ID is invalid.")
+
+    if service != "spotify" and service != "soundcloud":
+        raise APIBadRequest(f"Service {service} is not supported. We currently only support 'spotify' and 'soundcloud'.")
+
+    if service == "spotify":
+        spotify_service = SpotifyService()
+        token = spotify_service.get_user(user["id"], refresh=True)
+    elif service == "soundcloud":
+        soundcloud_service = SoundCloudService()
+        token = soundcloud_service.get_user(user["id"])
+
+    if not token:
+        raise APIBadRequest(f"Service {service} is not linked. Please link your {service} account first.")
+
+    if service == 'spotify' and not SPOTIFY_PLAYLIST_PERMISSIONS.issubset(set(token["scopes"])):
+        raise APIBadRequest(f"Missing scopes playlist-modify-public and playlist-modify-private to export playlists."
+                            f" Please relink your {service} account from ListenBrainz settings with appropriate scopes"
+                            f" to use this feature.")
+
+    is_public = parse_boolean_arg("is_public", True)
+    try:
+        if service == "spotify":
+            url = export_to_spotify(user["auth_token"], token["access_token"], is_public, playlist_mbid=playlist_mbid)
+        else:
+            url = export_to_soundcloud(user["auth_token"], token["access_token"], is_public, playlist_mbid=playlist_mbid)
+        return jsonify({"external_url": url})
+    except requests.exceptions.HTTPError as exc:
+        error = exc.response.json()
+        raise APIError(error.get("error") or exc.response.reason, exc.response.status_code)
+
+
 @playlist_api_bp.route("/export-jspf/<service>", methods=["POST", "OPTIONS"])
 @crossdomain
 @ratelimit()
@@ -1072,15 +1072,20 @@ def export_playlist_jspf(service):
     """
     user = validate_auth_header()
 
-    if service != "spotify":
-        raise APIBadRequest(f"Service {service} is not supported. We currently only support 'spotify'.")
+    if service != "spotify" and service != "soundcloud":
+        raise APIBadRequest(f"Service {service} is not supported. We currently only support 'spotify' and 'soundcloud'.")
+
+    if service == "spotify":
+        spotify_service = SpotifyService()
+        token = spotify_service.get_user(user["id"], refresh=True)
+    elif service == "soundcloud":
+        soundcloud_service = SoundCloudService()
+        token = soundcloud_service.get_user(user["id"])
 
-    spotify_service = SpotifyService()
-    token = spotify_service.get_user(user["id"], refresh=True)
     if not token:
         raise APIBadRequest(f"Service {service} is not linked. Please link your {service} account first.")
 
-    if not SPOTIFY_PLAYLIST_PERMISSIONS.issubset(set(token["scopes"])):
+    if service == 'spotify' and not SPOTIFY_PLAYLIST_PERMISSIONS.issubset(set(token["scopes"])):
         raise APIBadRequest(f"Missing scopes playlist-modify-public and playlist-modify-private to export playlists."
                             f" Please relink your {service} account from ListenBrainz settings with appropriate scopes"
                             f" to use this feature.")
@@ -1088,7 +1093,10 @@ def export_playlist_jspf(service):
     is_public = parse_boolean_arg("is_public", True)
     jspf = request.json
     try:
-        url = export_to_spotify(user["auth_token"], token["access_token"], is_public, jspf=jspf)
+        if service == "spotify":
+            url = export_to_spotify(user["auth_token"], token["access_token"], is_public, jspf=jspf)
+        else:
+            url = export_to_soundcloud(user["auth_token"], token["access_token"], is_public, jspf=jspf)
         return jsonify({"external_url": url})
     except requests.exceptions.HTTPError as exc:
         error = exc.response.json()

From d5b65b0be0d7b3705d0ab20409fd275ef7f807aa Mon Sep 17 00:00:00 2001
From: Rimma Kubanova <rimma.kubanova@gmail.com>
Date: Fri, 23 Aug 2024 15:19:29 +0500
Subject: [PATCH 6/9] fixed typo

---
 listenbrainz/webserver/views/playlist_api.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/listenbrainz/webserver/views/playlist_api.py b/listenbrainz/webserver/views/playlist_api.py
index 68e1a163a3..4530c55f21 100644
--- a/listenbrainz/webserver/views/playlist_api.py
+++ b/listenbrainz/webserver/views/playlist_api.py
@@ -1026,7 +1026,7 @@ def export_playlist(playlist_mbid, service):
         log_raise_400("Provided playlist ID is invalid.")
 
     if service != "spotify" and service != "soundcloud":
-        raise APIBadRequest(f"Service {service} is not supported. We currently only support 'spotify' and 'soundcloud'.")
+        raise APIBadRequest(f"Service {service} is not supported. We currently only support 'spotify'.")
 
     if service == "spotify":
         spotify_service = SpotifyService()
@@ -1073,7 +1073,7 @@ def export_playlist_jspf(service):
     user = validate_auth_header()
 
     if service != "spotify" and service != "soundcloud":
-        raise APIBadRequest(f"Service {service} is not supported. We currently only support 'spotify' and 'soundcloud'.")
+        raise APIBadRequest(f"Service {service} is not supported. We currently only support 'spotify'.")
 
     if service == "spotify":
         spotify_service = SpotifyService()

From bbb0c751b5964f33cc69fa99f067ea35e564adb7 Mon Sep 17 00:00:00 2001
From: Rimma Kubanova <rimma.kubanova@gmail.com>
Date: Tue, 27 Aug 2024 19:19:54 +0500
Subject: [PATCH 7/9] removed log

---
 listenbrainz/webserver/views/playlist_api.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/listenbrainz/webserver/views/playlist_api.py b/listenbrainz/webserver/views/playlist_api.py
index 4530c55f21..034f551699 100644
--- a/listenbrainz/webserver/views/playlist_api.py
+++ b/listenbrainz/webserver/views/playlist_api.py
@@ -895,6 +895,7 @@ def import_playlist_from_music_service(service):
         elif service == "soundcloud":
             soundcloud = SoundCloud(token["access_token"])
             playlists = soundcloud.get("https://api.soundcloud.com/me/playlists/")
+            print(token["access_token"])
             return jsonify(playlists)
 
     except requests.exceptions.HTTPError as exc:

From ab9398389bb2a09ca63ed91f820c1efa5c2f5ec5 Mon Sep 17 00:00:00 2001
From: anshg1214 <anshg1214@gmail.com>
Date: Fri, 30 Aug 2024 11:09:34 +0000
Subject: [PATCH 8/9] format: Lint files

---
 frontend/js/src/utils/soundcloudTypes.d.ts   | 56 ++++++++++----------
 listenbrainz/webserver/views/playlist_api.py |  2 +-
 2 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/frontend/js/src/utils/soundcloudTypes.d.ts b/frontend/js/src/utils/soundcloudTypes.d.ts
index 6c246d1d94..8025da9b38 100644
--- a/frontend/js/src/utils/soundcloudTypes.d.ts
+++ b/frontend/js/src/utils/soundcloudTypes.d.ts
@@ -1,39 +1,39 @@
 declare type SoundCloudUser = {
-    access_token?: string;
-  };
+  access_token?: string;
+};
 
 declare type SoundCloudTrackObject = {
+  id: string;
+  permalink_url: string;
+  artwork_url?: string;
+  title: string;
+  uri: string;
+  duration: number;
+  user: {
     id: string;
-    permalink_url: string;
-    artwork_url?: string;
-    title: string;
-    uri: string;
-    duration: number;
-    user: {
-      id: string;
-      username: string;
-      avatar_url?: string;
-    };
+    username: string;
+    avatar_url?: string;
+  };
 };
 
 declare type SoundCloudPlaylistObject = {
-    id: string;
-    title: string;
-    description?: string;
-    tracks: SoundCloudTrackObject[];
-    created_at: string;
-    duration: number;
-    artwork_url?: string;
-    genre?: string;
-    user: {
-      id: number;
-      username: string;
-      avatar_url?: string; 
-    };
+  id: string;
+  title: string;
+  description?: string;
+  tracks: SoundCloudTrackObject[];
+  created_at: string;
+  duration: number;
+  artwork_url?: string;
+  genre?: string;
+  user: {
+    id: number;
+    username: string;
+    avatar_url?: string;
+  };
 };
 
 declare type SoundcloudAPIError = {
-    code: integer;
-    message: string;
-    link: string;
+  code: integer;
+  message: string;
+  link: string;
 };
diff --git a/listenbrainz/webserver/views/playlist_api.py b/listenbrainz/webserver/views/playlist_api.py
index 034f551699..2f942db50e 100644
--- a/listenbrainz/webserver/views/playlist_api.py
+++ b/listenbrainz/webserver/views/playlist_api.py
@@ -1011,7 +1011,7 @@ def import_tracks_from_soundcloud_playlist(playlist_id):
 def export_playlist(playlist_mbid, service):
     """
 
-    Export a playlist to an external service, given a playlist MBID. 
+    Export a playlist to an external service, given a playlist MBID.
 
     :reqheader Authorization: Token <user token>
     :param playlist_mbid: The playlist mbid to export.

From 771fc684dfdd93c41c4b13417aa272e699c4697c Mon Sep 17 00:00:00 2001
From: Rimma Kubanova <rimma.kubanova@gmail.com>
Date: Mon, 2 Sep 2024 15:37:32 +0500
Subject: [PATCH 9/9] fixed minor errors

---
 .../components/ImportSoundCloudPlaylistModal.tsx         | 9 +++++----
 listenbrainz/metadata_cache/soundcloud/client.py         | 4 ----
 listenbrainz/webserver/views/playlist_api.py             | 1 -
 3 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/frontend/js/src/user/playlists/components/ImportSoundCloudPlaylistModal.tsx b/frontend/js/src/user/playlists/components/ImportSoundCloudPlaylistModal.tsx
index bc456e15d4..ebbe538abb 100644
--- a/frontend/js/src/user/playlists/components/ImportSoundCloudPlaylistModal.tsx
+++ b/frontend/js/src/user/playlists/components/ImportSoundCloudPlaylistModal.tsx
@@ -45,12 +45,13 @@ export default NiceModal.create((props: ImportPLaylistModalProps) => {
           <ToastMsg
             title="Error loading playlists"
             message={
-              error?.message === "Forbidden" ? (
+              error?.message === "Unauthorized" ? (
                 <>
                   Session has expired. Please reconnect to{" "}
-                  <Link to="/settings/music-services/details/">Soundcloud</Link>
-                  .
+                  <Link to="/settings/music-services/details/">Soundcloud</Link>.
                 </>
+              ) : error?.message === "Not Found" ? (
+                "The requested resource was not found."
               ) : (
                 error?.message ?? error
               )
@@ -101,7 +102,7 @@ export default NiceModal.create((props: ImportPLaylistModalProps) => {
           message={
             <>
               Imported
-              <a href={newPlaylist.identifier}> {playlistName}</a>
+              <Link to={newPlaylist.identifier}> {playlistName}</Link>
             </>
           }
         />,
diff --git a/listenbrainz/metadata_cache/soundcloud/client.py b/listenbrainz/metadata_cache/soundcloud/client.py
index 9a8557bfc9..6e65f40c26 100644
--- a/listenbrainz/metadata_cache/soundcloud/client.py
+++ b/listenbrainz/metadata_cache/soundcloud/client.py
@@ -1,11 +1,7 @@
 import requests
-from requests import RequestException
 from requests.adapters import HTTPAdapter
 from urllib3 import Retry
 
-from listenbrainz.domain.soundcloud import SoundCloudService
-from listenbrainz.webserver.errors import APIForbidden
-
 SOUNDCLOUD_URL = 'https://api.soundcloud.com'
 
 
diff --git a/listenbrainz/webserver/views/playlist_api.py b/listenbrainz/webserver/views/playlist_api.py
index 034f551699..4530c55f21 100644
--- a/listenbrainz/webserver/views/playlist_api.py
+++ b/listenbrainz/webserver/views/playlist_api.py
@@ -895,7 +895,6 @@ def import_playlist_from_music_service(service):
         elif service == "soundcloud":
             soundcloud = SoundCloud(token["access_token"])
             playlists = soundcloud.get("https://api.soundcloud.com/me/playlists/")
-            print(token["access_token"])
             return jsonify(playlists)
 
     except requests.exceptions.HTTPError as exc: