Search, view tracks websocket endpoints, service to like media.

custom_components/spotcast/config_flow/config_flow_handler.py

@@ -117,7 +117,7 @@ async def async_oauth_create_entry(
             await private_session.async_ensure_token_valid()
             accounts: dict[str, Spotify] = {
                 "public": Spotify(auth=external_api["token"]["access_token"]),
-                "private": Spotify(auth=private_session.token)
+                "private": Spotify(auth=private_session.clean_token)
             }
 
             profiles = {}

custom_components/spotcast/icons.json

@@ -26,6 +26,9 @@
         },
         "play_saved_episodes": {
             "service": "mdi:podcast"
+        },
+        "like_media": {
+            "service": "mdi:music-note-plus"
         }
     }
 }

custom_components/spotcast/services.yaml

@@ -301,7 +301,29 @@ add_to_queue:
   fields:
     spotify_uris:
       name: Spotify URIs
-      description: A list of spotify URIs
+      description: A list of Spotify URIs
+      required: true
+      selector:
+        object:
+          uris:
+            - name: URIs
+              selector:
+                text:
+                  multiline: false
+    account:
+      name: Spotify Account
+      description: The id of the spotify account to use. Takes the default account otherwise
+      required: false
+      selector:
+        config_entry:
+          integration: spotcast
+like_media:
+  name: Like Media
+  description: Save a list of Media to your Spotify Library
+  fields:
+    spotify_uris:
+      name: Spotify URIs
+      description: A list of Spotify URIs
       required: true
       selector:
         object:

custom_components/spotcast/services/const.py

@@ -38,6 +38,10 @@
     PLAY_SAVED_EPISODES,
     async_play_saved_episodes,
 )
+from custom_components.spotcast.services.like_media import (
+    LIKE_MEDIA_SCHEMA,
+    async_like_media,
+)
 
 SERVICE_SCHEMAS = MappingProxyType({
     "play_media": PLAY_MEDIA_SCHEMA,
@@ -49,6 +53,7 @@
     "play_from_search": PLAY_FROM_SEARCH_SCHEMA,
     "add_to_queue": ADD_TO_QUEUE_SCHEMA,
     "play_saved_episodes": PLAY_SAVED_EPISODES,
+    "like_media": LIKE_MEDIA_SCHEMA,
 })
 
 SERVICE_HANDLERS = MappingProxyType({
@@ -61,4 +66,5 @@
     "play_from_search": async_play_from_search,
     "add_to_queue": async_add_to_queue,
     "play_saved_episodes": async_play_saved_episodes,
+    "like_media": async_like_media
 })

custom_components/spotcast/services/like_media.py

@@ -0,0 +1,37 @@
+"""Module to like a (list) of spotify uris
+
+Functions:
+    - async_like_media
+"""
+
+from logging import getLogger
+
+from homeassistant.core import HomeAssistant, ServiceCall
+from homeassistant.helpers import config_validation as cv
+import voluptuous as vol
+
+from custom_components.spotcast.spotify import SpotifyAccount
+from custom_components.spotcast.utils import get_account_entry
+from custom_components.spotcast.spotify.utils import url_to_uri
+
+LOGGER = getLogger(__name__)
+
+LIKE_MEDIA_SCHEMA = vol.Schema({
+    vol.Required("spotify_uris"): vol.All(cv.ensure_list, [url_to_uri]),
+    vol.Optional("account"): cv.string,
+})
+
+
+async def async_like_media(hass: HomeAssistant, call: ServiceCall):
+    """Service to add like a (list) of spotify uris"""
+    uris = call.data.get("spotify_uris")
+    account_id = call.data.get("account")
+
+    entry = get_account_entry(hass, account_id)
+    LOGGER.debug("Loading Spotify Account for User `%s`", account_id)
+    account = await SpotifyAccount.async_from_config_entry(
+        hass=hass,
+        entry=entry
+    )
+
+    await account.async_like_media(uris)

custom_components/spotcast/spotify/account.py

@@ -34,6 +34,7 @@
     TokenError,
 )
 
+
 LOGGER = getLogger(__name__)
 
 
@@ -51,7 +52,7 @@ class SpotifyAccount:
 
     Properties:
         - id(str): the identifier of the account
-        - name(str): the dusplay name for the account
+        - name(str): the display name for the account
         - profile(dict): the full profile dictionary of the account
         - country(str): the country code where the account currently
             is.
@@ -84,8 +85,10 @@ class SpotifyAccount:
         - async_apply_extras
         - async_shuffle
         - async_liked_songs
+        - async_like_media
         - async_repeat
         - async_set_volume
+        - async_view
 
     Functions:
         - async_from_config_entry
@@ -893,6 +896,22 @@ async def async_liked_songs(self, force: bool = False) -> list[str]:
 
         return self.liked_songs
 
+    async def async_like_media(self, uris: list[str]):
+        """Adds a list of uris to the user's liked songs"""
+        await self.async_ensure_tokens_valid()
+
+        dataset = self._datasets["liked_songs"]
+
+        # Force expire the liked_songs dataset
+        async with dataset.lock:
+            dataset.expires_at = 0
+            LOGGER.debug("Expired liked_songs dataset after adding new likes")
+
+            await self.hass.async_add_executor_job(
+                self.apis["private"].current_user_saved_tracks_add,
+                uris,
+            )
+
     async def async_repeat(
         self,
         state: str,
@@ -1003,6 +1022,72 @@ async def async_category_playlists(
 
         return playlists
 
+    async def async_view(
+        self,
+        url: str,
+        language: str = None,
+        limit: int = None,
+    ) -> list[dict]:
+        """Fetches a view based on url.
+
+        Args:
+            - url(str): The url of the view to fetch (e.g.,
+                'made-for-x').
+            - language(str, optional): The ISO-639-1 language code to
+                show the view in. If None, defaults to en_US. Default
+                is None.
+            - limit(int, optional): The maximum number of playlists to
+                retrieve. If None, retrieves all items. Defaults to
+                None.
+
+        Returns:
+            - list: A list of playlists.
+        """
+
+        await self.async_ensure_tokens_valid()
+
+        locale = None if language is None else f"{language}_{self.country}"
+
+        return await self._async_pager(
+            function=self._fetch_view,
+            prepends=[url, locale],
+            limit=25,  # This is the max amount per call
+            max_items=limit,
+            sub_layer="content",
+        )
+
+    def _fetch_view(
+        self,
+        url: str,
+        locale: str,
+        limit: int = 25,
+        offset: int = 0,
+    ) -> dict:
+        """Retrieve a page from a view
+
+        Args:
+            - url(str): the endpoint to retrieve
+            - locale(str): an ISO-639-2 language code
+            - limit(int, optional): the maximum number of item to
+                retrieve in each call. Defaults to 25.
+            - offset(int, optional): the starting index from which to
+                retrieve elements. Defaults to 0.
+
+        Returns:
+            - dict: an api reply containing the content of a view
+        """
+
+        params = {
+            "content_limit": limit,
+            "locale": locale,
+            "platform": "web",
+            "types": "album,playlist,artist,show,station",
+            "limit": limit,
+            "offset": offset,
+        }
+
+        return self.apis["private"]._get(url, params)
+
     async def _async_get_count(
             self,
             function: callable,