radio5 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dbd8b7a0f0f52fbd61723bdadc3ce5391e06569ac5dd14af9179a5686b7144c
-  data.tar.gz: ace0a638624953a08f543ddb34646c2a13b2f661db12e79ca3527184d9723410
+  metadata.gz: afc335b6a9726ff30f27942868b19513b02aea353144fcd8f283bc8da3fe1159
+  data.tar.gz: 41852476ae434f3718e68d2c60d8fc7b868425288efeae519024d766e7d06b94
 SHA512:
-  metadata.gz: 1a6ba08b636344e53094fd718f7c63f60047ebb5ea8e12d0e274f4bb828792cc0eeb9748d3ecbe718d409c573c76c0e3632bcd2214ed7bd9702078a0572db4dd
-  data.tar.gz: b42658c994bb9dd6b0c1b06bd97f9eb19032031a6f82752dbcc1bd0d8d8bdbfad1da647a0f20bf8f51b83481546ab1c1b2f397d7359c5b62f9786e951b53a31e
+  metadata.gz: 8be48ecc1b8681d7749775473b9b3af13aa469aa3098a2896ffbb026056b696d3135924b19d1ff4ff79c9e6e50a6c05cb9f270372874b52c2df48401d504d72e
+  data.tar.gz: 639fab8c48fe128066118ebcf79e72baf3aa6ef5d104540b03bbc30d51b3f77163d9cd348fa52cc6c2b23e75027cd224d77d42ba80f7efe288d067c112628781

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+0.2.0
+----------
+
+- Added users endpoints support
+- Replaced `track[:cover]` with `track[:cover_url]` with extended format (per size) as with users
+
+0.1.2
+----------
+
+- Fixed bug when custom HTTP config was ignored
+- Fixed bug with broken HTTP retries
+
 0.1.1
 ----------
 

data/README.md

@@ -1,7 +1,7 @@
 # Radio5
 
 [![Gem Version](https://badge.fury.io/rb/radio5.svg)](https://badge.fury.io/rb/radio5)
-[![Build](https://github.com/ocvit/radio5/workflows/Build/badge.svg)](https://github.com/ocvit/radio5/actions)
+[![Test](https://github.com/ocvit/radio5/workflows/Test/badge.svg)](https://github.com/ocvit/radio5/actions)
 [![Coverage Status](https://coveralls.io/repos/github/ocvit/radio5/badge.svg?branch=main)](https://coveralls.io/github/ocvit/radio5?branch=main)
 
 Adapter for [Radiooooo](https://radiooooo.com/) private API.
@@ -47,7 +47,7 @@ client = Radio5::Client.new(
 )
 ```
 
-## Usage
+## Tracks
 
 To get random track:
 
@@ -64,7 +64,12 @@ client.random_track
 #   songwriter: "Bart Howard",
 #   length: 133,
 #   info: "It is the original recording of Fly me to the moon !",
-#   cover_url: "https://asset.radiooooo.com/cover/USA/1950/large/<uuid>_1.jpg",
+#   cover_url: {
+#     thumb: "https://asset.radiooooo.com/cover/USA/1950/thumb/<uuid>_1.jpg",
+#     small: "https://asset.radiooooo.com/cover/USA/1950/small/<uuid>_1.jpg",
+#     medium: "https://asset.radiooooo.com/cover/USA/1950/medium/<uuid>_1.jpg",
+#     large: "https://asset.radiooooo.com/cover/USA/1950/large/<uuid>_1.jpg",
+#   },
 #   audio: {
 #     mpeg: {
 #       url: "https://radiooooo-track.b-cdn.net/USA/1950/<uuid>.mp3?token=<token>&expires=1704717060",
@@ -120,12 +125,12 @@ client.track("655f7bb24b0d722a021a2cf2")
 # output is exactly the same as from `#random_track`, but `created_at` is now filled
 ```
 
+## Countries / decades / moods
+
 OK, what input parameters are available?
 
 ```ruby
-# list of countries + additional info:
-#   - `exist` - "is it still around" flag
-#   - `rank`  - subjective ranking provided by the website, only 10 countries have it
+# countries
 client.countries
 # => {
 #   "AFG" => {name: "Afganistan", exist: true, rank: nil},
@@ -133,6 +138,10 @@ client.countries
 #   "FRA" => {name: "France", exist: true, rank: 2},
 #   ...
 # }
+#
+# NOTES:
+#   - `exist` - "is it still around" flag
+#   - `rank`  - subjective ranking provided by the website, only 10 countries have it
 
 # decades
 client.decades
@@ -142,10 +151,10 @@ client.decades
 client.moods
 # => [:fast, :slow, :weird]
 #
-# NOTE: by default all 3 moods are used in `#random_track` and `#island_track`
+# NOTE: all 3 moods are used in `#random_track` and `#island_track` by default
 ```
 
-It's also possible to get all valid `country`/`decade`/`moods` combinations in advance:
+It's also possible to get all valid `country`/ `moods` combinations per for specific decade in advance:
 
 ```ruby
 # grouped by country
@@ -168,10 +177,13 @@ client.countries_for_decade(1960, group_by: :mood)
 # }
 ```
 
-How to work with the "islands" ("playlists" in the simple words):
+## Islands
+
+Islands work as a kind of thematic collections.
+
+To get a list of all islands:
 
 ```ruby
-# list all islands
 client.islands
 # => [{
 #   id: "5d330a3e06fb03d8872a3316",
@@ -208,22 +220,119 @@ client.islands
 #   - `play_mode`  - it is somehow used in a web app
 #   - `created_by` - `id` of user who created this island
 #   - `updated_by` - ...and who updated it last time
+```
+
+To get random track from selected island:
 
-# to get random track from selected island
+```ruby
 client.island_track(island_id: "5d330a3e06fb03d8872a3316")
 
 # it's also possible to specify moods
 client.island_track(island_id: "5d330a3e06fb03d8872a3316", moods: [:fast, :weird])
 ```
 
-User endpoints - WIP.
+## Users
+
+To get information about specific user using its `id`:
+
+```ruby
+client.user("5d3306de06fb03d8871fd138")
+# => {
+#   id: "5d3306de06fb03d8871fd138",
+#   uuid: <uuid>,
+#   name: "Paul Charmant-Kabil",
+#   info: "Dreamseeker",
+#   country: "FRA",
+#   rank: 9188,
+#   image_url: {
+#     icon: "https://asset.radiooooo.com/user/1409/icon/<uuid>_3.jpg",
+#     thumb: "https://asset.radiooooo.com/user/1409/thumb/<uuid>_3.jpg",
+#     small: "https://asset.radiooooo.com/user/1409/small/<uuid>_3.jpg",
+#     medium: "https://asset.radiooooo.com/user/1409/medium/<uuid>_3.jpg",
+#     large: "https://asset.radiooooo.com/user/1409/large/<uuid>_3.jpg"
+#   },
+#   birthday: {
+#     time: 1981-01-31 23:01:01 UTC,
+#     year_normalized: 1981
+#   },
+#   created_at: 2014-09-30 18:58:32 UTC
+# }
+#
+# NOTES:
+#   - `rank` - is not unique
+#   - `birthday`:
+#      - `time` - original time from API, it is always around first day of Jan or last day of
+#                 December, with a strange hour offset around midnight, so it looks like the
+#                 only real value here is the year
+#      - `year_normalized` - de-offset'ed year
+```
+
+To get user followers or followings counts:
+
+```ruby
+client.user_follow_counts("5d3306de06fb03d8871fd138")
+# => {
+#   followings: 17,
+#   followers: 866
+# }
+```
+
+To get list of user followers:
+
+```ruby
+# all followers will be returned by default
+client.user_followers("5d3306de06fb03d8871fd138")
+# => [{
+#   id: "5f8f175051430765bd5c1b08",
+#   name: "Philart",
+#   country: "FRA",
+#   rank: 25,
+#   image_url: {
+#     icon: "https://asset.radiooooo.com/user/2010/icon/<uuid>_1.jpg",
+#     thumb: "https://asset.radiooooo.com/user/2010/thumb/<uuid>_1.jpg",
+#     small: "https://asset.radiooooo.com/user/2010/small/<uuid>_1.jpg",
+#     medium: "https://asset.radiooooo.com/user/2010/medium/<uuid>_1.jpg",
+#     large: "https://asset.radiooooo.com/user/2010/large/<uuid>_1.jpg"
+#   },
+#   created_at: 2020-10-20 16:58:56.819 UTC
+# }, ...]
+
+# it's also possible to specify size/page
+client.user_followers("5d3306de06fb03d8871fd138", size: 1, page: 5)
+# => [{...}]
+```
+
+To get list of user followings:
+
+```ruby
+# all followings will be returned by default
+client.user_followings("5d3306de06fb03d8871fd138")
+# => [{
+#   id: "640ab0cebf47667afdbf9edb",
+#   name: "Cap Jones",
+#   country: "USA",
+#   rank: 5,
+#   image_url: {
+#     icon: "https://asset.radiooooo.com/user/2303/icon/<uuid>_1.jpg",
+#     thumb: "https://asset.radiooooo.com/user/2303/thumb/<uuid>_1.jpg",
+#     small: "https://asset.radiooooo.com/user/2303/small/<uuid>_1.jpg",
+#     medium: "https://asset.radiooooo.com/user/2303/medium/<uuid>_1.jpg",
+#     large: "https://asset.radiooooo.com/user/2303/large/<uuid>_1.jpg"
+#   },
+#   created_at: 2023-03-10 04:23:42.87 UTC
+# }, ...]
+
+# it's also possible to specify size/page
+client.user_followings("5d3306de06fb03d8871fd138", size: 1, page: 5)
+# => [{...}]
+```
 
 ## Auth?
 
-There is just a couple of features that require login and/or premium account:
+There is just a couple of features that require login (free or premium account):
 
-- history of "listened" tracks - track becomes "listened" when you got it via `#random_track` or `#island_track` (free)
-- `followed` flag for `#user` - indicates whether or not you follow this user (free)
+- `#track_history` - list of tracks you "listened" via `#random_track` or `#island_track` (free)
+- `user[:followed]` flag - indicates whether or not you follow this user (free)
 - `#user_liked_tracks` - list of tracks which user really vibed to (free)
 - ability to use multiple countries as a filter in `#random_track` (premium)
 
@@ -236,17 +345,17 @@ Currently auth is in a WIP state.
 - [x] Countries support  
 - [x] Islands support  
 - [x] Tracks support  
-- [ ] Users support  
+- [x] Users support  
 - [ ] Auth + auth'ed endpoints  
 
 ## Development
 
 ```sh
-bin/setup     // install deps
-bin/console   // interactive prompt to play around
-rake spec     // test!
-rake rubocop  // lint!
-sudo rm -rf / // relax, just kidding ^^
+bin/setup      // install deps
+bin/console    // interactive prompt to play around
+rake spec      // test!
+rake rubocop   // lint!
+sudo rm -rf /  // just kidding ^^
 ```
 
 ## Contributing

data/lib/radio5/api.rb

@@ -5,6 +5,7 @@ module Radio5
     class Error < StandardError; end
     class TrackNotFound < Error; end
     class MatchingTrackNotFound < Error; end
+    class UserNotFound < Error; end
     class UnexpectedResponse < StandardError; end
 
     HOST = "radiooooo.com"
@@ -39,6 +40,8 @@ module Radio5
           raise TrackNotFound
         in error: "No track for this selection"
           raise MatchingTrackNotFound
+        in error: "No info for this user"
+          raise UserNotFound
         in error: other_error
           raise Error, other_error
         else

data/lib/radio5/client/islands.rb

@@ -3,13 +3,19 @@
 module Radio5
   class Client
     module Islands
-      include Utils
-
-      # rubocop:disable Layout/HashAlignment
       def islands
         _, json = api.get("/island/all")
 
         json.map do |island|
+          Parser.island_info(island)
+        end
+      end
+
+      module Parser
+        extend Utils
+
+        # rubocop:disable Layout/HashAlignment
+        def self.island_info(island)
           rank_value = island[:sort]
           rank = rank_value if rank_value.is_a?(Integer)
 
@@ -30,9 +36,9 @@ module Radio5
             favourite_count: island[:favorites],
             play_count:      island.fetch(:plays),
             rank:            rank,
-            icon_url:        parse_asset_url(island, :icon),
-            splash_url:      parse_asset_url(island, :splash),
-            marker_url:      parse_asset_url(island, :marker),
+            icon_url:        parse_asset_url(island[:icon]),
+            splash_url:      parse_asset_url(island[:splash]),
+            marker_url:      parse_asset_url(island[:marker]),
             enabled:         island.fetch(:enabled),
             free:            island[:free],
             on_map:          island.fetch(:onmap),
@@ -44,8 +50,8 @@ module Radio5
             updated_by:      updated_by
           }
         end
+        # rubocop:enable Layout/HashAlignment
       end
-      # rubocop:enable Layout/HashAlignment
     end
   end
 end

data/lib/radio5/client/tracks.rb

@@ -69,6 +69,9 @@ module Radio5
           created_at = created_node && parse_time_string(created_node.fetch(:date))
           created_by = created_node ? created_node.fetch(:user_id) : json.fetch(:profile_id)
 
+          cover_node = json[:image] || json[:cover]
+          cover_url = parse_image_urls(cover_node, entity: :track)
+
           audio = {
             mpeg: track_audio(json, :mpeg),
             ogg:  track_audio(json, :ogg)
@@ -85,7 +88,7 @@ module Radio5
             songwriter:  normalize_string(json[:songwriter]),
             length:      json.fetch(:length),
             info:        normalize_string(json[:info]),
-            cover_url:   parse_asset_url(json, :image, size: "large"),
+            cover_url:   cover_url,
             audio:       audio,
             decade:      json.fetch(:decade),
             mood:        symbolize_mood(json.fetch(:mood)),
@@ -110,7 +113,6 @@ module Radio5
           }
         end
       end
-      private_constant :Parser
     end
   end
 end

data/lib/radio5/client/users.rb

@@ -3,9 +3,141 @@
 module Radio5
   class Client
     module Users
-      def user
-        # ...
+      def user(id)
+        validate_user_id!(id)
+
+        _, json = api.get("/contributor/#{id}")
+
+        Parser.user_info(json)
+      rescue Api::UserNotFound
+        nil
+      end
+
+      def user_tracks(id, status: :on_air, size: MAX_PAGE_SIZE, page: 1)
+        validate_user_id!(id)
+        validate_user_track_status!(status)
+        validate_page_size!(size)
+        validate_page_number!(page)
+
+        query_params = {
+          status: stringify_user_track_status(status),
+          size: size,
+          page: page
+        }
+
+        _, json = api.get("/contributor/uploaded/#{id}", query_params: query_params)
+
+        json.map do |track|
+          Parser.user_track_info(track)
+        end
+      end
+
+      def user_follow_counts(id)
+        validate_user_id!(id)
+
+        _, json = api.get("/follow/count/#{id}")
+
+        {
+          followings: json.fetch(:following),
+          followers: json.fetch(:followers)
+        }
+      end
+
+      def user_followers(id, size: MAX_PAGE_SIZE, page: 1)
+        validate_user_id!(id)
+        validate_page_size!(size)
+        validate_page_number!(page)
+
+        _, json = api.get("/follow/list/follower/#{id}", query_params: {size: size, page: page})
+
+        json.map do |user|
+          Parser.follow_user_info(user)
+        end
+      end
+
+      def user_followings(id, size: MAX_PAGE_SIZE, page: 1)
+        validate_user_id!(id)
+        validate_page_size!(size)
+        validate_page_number!(page)
+
+        _, json = api.get("/follow/list/following/#{id}", query_params: {size: size, page: page})
+
+        json.map do |user|
+          Parser.follow_user_info(user)
+        end
+      end
+
+      def user_liked_tracks
+        raise NotImplementedError, "depends on auth"
+      end
+
+      # rubocop:disable Layout/HashAlignment
+      module Parser
+        extend Utils
+
+        def self.user_info(json)
+          birthday = if json[:birthday]
+            time = parse_time_string(json[:birthday])
+            year_normalized = normalize_year(time)
+
+            {
+              time: time,
+              year_normalized: year_normalized
+            }
+          end
+
+          {
+            id:         json.fetch(:_id),
+            uuid:       json.fetch(:uuid),
+            name:       normalize_string(json.fetch(:pseudonym)),
+            info:       normalize_string(json[:info]),
+            country:    json[:country],
+            rank:       json.fetch(:ranking),
+            image_url:  parse_image_urls(json[:image], entity: :user),
+            birthday:   birthday,
+            created_at: parse_time_string(json.fetch(:created))
+          }
+        end
+
+        def self.user_track_info(track)
+          cover_node = track[:image] || track[:cover]
+          cover_url = parse_image_urls(cover_node, entity: :track)
+
+          {
+            id:          track.fetch(:_id),
+            uuid:        track.fetch(:uuid),
+            artist:      normalize_string(track.fetch(:artist)),
+            title:       normalize_string(track.fetch(:title)),
+            year:        normalize_string(track.fetch(:year)),
+            cover_url:   cover_url,
+            decade:      track.fetch(:decade),
+            country:     track.fetch(:country),
+            like_count:  track.fetch(:likes),
+            status:      symbolize_user_track_status(track[:status])
+          }
+        end
+
+        # TODO: strange name tbh, change later
+        def self.follow_user_info(user)
+          {
+            id:         user.fetch(:_id),
+            name:       normalize_string(user.fetch(:pseudonym)),
+            country:    user[:country],
+            rank:       user.fetch(:ranking),
+            image_url:  parse_image_urls(user[:image], entity: :user),
+            created_at: parse_time_string(user.fetch(:created))
+          }
+        end
+
+        def self.normalize_year(time)
+          if time.month == 12
+            time.year + 1
+          else
+            time.year
+          end
+        end
       end
+      # rubocop:enable Layout/HashAlignment
     end
   end
 end

data/lib/radio5/client.rb

@@ -22,8 +22,8 @@ module Radio5
       @open_timeout = open_timeout
       @read_timeout = read_timeout
       @write_timeout = write_timeout
-      @max_retries = max_retries
       @proxy_url = proxy_url
+      @max_retries = max_retries
       @debug_output = debug_output
     end
 

data/lib/radio5/http.rb

@@ -9,12 +9,15 @@ module Radio5
     DEFAULT_OPEN_TIMEOUT = 10 # seconds
     DEFAULT_READ_TIMEOUT = 10 # seconds
     DEFAULT_WRITE_TIMEOUT = 10 # seconds
-    DEFAULT_DEBUG_OUTPUT = nil
+    DEFAULT_PROXY_URL = nil
     DEFAULT_MAX_RETRIES = 3
+    DEFAULT_DEBUG_OUTPUT = nil
+
     DEFAULT_HEADERS = {
       "Content-Type" => "application/json; charset=utf-8",
       "User-Agent" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
     }.freeze
+
     RETRIABLE_ERRORS = [
       Errno::ECONNREFUSED,
       Errno::ECONNRESET,
@@ -25,41 +28,45 @@ module Radio5
       OpenSSL::SSL::SSLError
     ].freeze
 
+    attr_reader :host, :port, :open_timeout, :read_timeout, :write_timeout, :proxy_url, :max_retries, :debug_output, :http_client
+
     # rubocop:disable Layout/ExtraSpacing
     def initialize(
       host:,
       port:,
-      open_timeout: DEFAULT_OPEN_TIMEOUT,
-      read_timeout: DEFAULT_READ_TIMEOUT,
-      write_timeout: DEFAULT_WRITE_TIMEOUT,
+      open_timeout: nil,
+      read_timeout: nil,
+      write_timeout: nil,
       proxy_url: nil,
-      max_retries: DEFAULT_MAX_RETRIES,
-      debug_output: DEFAULT_DEBUG_OUTPUT
+      max_retries: nil,
+      debug_output: nil
     )
-      # @host          = host
-      # @port          = port
-      # @open_timeout  = open_timeout
-      # @read_timeout  = read_timeout
-      # @write_timeout = write_timeout
-      # @proxy_url     = proxy_url
-      # @debug_output  = debug_output
-
-      proxy_uri = parse_proxy_uri(proxy_url)
-      @max_retries = max_retries
-
-      @http = Net::HTTP.new(host, port, proxy_uri&.host, proxy_uri&.port, proxy_uri&.user, proxy_uri&.pass)
-
-      @http.tap do |c|
-        c.use_ssl       = port == 443
-        c.open_timeout  = open_timeout
-        c.read_timeout  = read_timeout
-        c.write_timeout = write_timeout
-
-        c.set_debug_output(debug_output)
+      @host          = host
+      @port          = port
+      @open_timeout  = open_timeout  || DEFAULT_OPEN_TIMEOUT
+      @read_timeout  = read_timeout  || DEFAULT_READ_TIMEOUT
+      @write_timeout = write_timeout || DEFAULT_WRITE_TIMEOUT
+      @proxy_url     = proxy_url     || DEFAULT_PROXY_URL
+      @max_retries   = max_retries   || DEFAULT_MAX_RETRIES
+      @debug_output  = debug_output  || DEFAULT_DEBUG_OUTPUT
+
+      @http_client = Net::HTTP.new(@host, @port, proxy_uri&.host, proxy_uri&.port, proxy_uri&.user, proxy_uri&.password)
+
+      @http_client.tap do |c|
+        c.use_ssl       = @port == 443
+        c.open_timeout  = @open_timeout
+        c.read_timeout  = @read_timeout
+        c.write_timeout = @write_timeout
+
+        c.set_debug_output(@debug_output)
       end
     end
     # rubocop:enable Layout/ExtraSpacing
 
+    def proxy_uri
+      @proxy_uri ||= parse_proxy_uri
+    end
+
     def request(http_method_class, path, query_params, body, headers)
       request = build_request(http_method_class, path, query_params, body, headers)
       make_request(request)
@@ -67,16 +74,15 @@ module Radio5
 
     private
 
-    def parse_proxy_uri(proxy_url)
+    def parse_proxy_uri
       return if proxy_url.nil?
 
-      proxy_uri = URI(proxy_url)
-
-      unless @proxy_uri.is_a?(URI::HTTP)
-        raise ArgumentError, "Invalid proxy URL: #{@proxy_uri}"
+      case uri = URI(proxy_url)
+      when URI::HTTP
+        uri
+      else
+        raise ArgumentError, "Invalid proxy URL: #{proxy_url.inspect}, parsed URI: #{uri.inspect}"
       end
-
-      proxy_uri
     end
 
     def build_request(http_method_class, path, query_params, body, headers)
@@ -109,9 +115,9 @@ module Radio5
     end
 
     def make_request(request, retries: 0)
-      @http.request(request)
+      http_client.request(request)
     rescue *RETRIABLE_ERRORS => error
-      if retries < @max_retries
+      if retries < max_retries
         make_request(request, retries: retries + 1)
       else
         raise error

data/lib/radio5/regexps.rb

@@ -2,6 +2,8 @@
 
 module Radio5
   module Regexps
+    include Utils
+
     # rubocop:disable Layout/ExtraSpacing
 
     MONGO_ID     = /^[a-f\d]{24}$/.freeze
@@ -11,18 +13,28 @@ module Radio5
     COUNTRY_ISO_CODE_GENERIC = /([A-Z]{3}|KN1)/.freeze
     COUNTRY_ISO_CODE         = /^#{COUNTRY_ISO_CODE_GENERIC}$/.freeze
 
-    ASSET_URL = lambda do |sub_path, exts|
+    ASSET_URL = lambda do |sub_path, exts, size = nil|
       asset_host = Regexp.escape(Utils::ASSET_HOST)
       sub_path   = sub_path.is_a?(Regexp) ? sub_path : Regexp.escape(sub_path)
       exts       = /(#{exts.join("|")})/
+      size       = /\/#{size}/ if size
 
-      /#{asset_host}#{sub_path}\/#{UUID_GENERIC}(_\d+)?\.#{exts}/
+      /#{asset_host}#{sub_path}#{size}\/#{UUID_GENERIC}(_\d+)?\.#{exts}/
     end.freeze
 
     ISLAND_ICON_URL   = ASSET_URL.call("/island/icon", ["png", "svg"]).freeze
     ISLAND_SPLASH_URL = ASSET_URL.call("/island/splash", ["png", "svg"]).freeze
     ISLAND_MARKER_URL = ASSET_URL.call("/island/marker", ["png", "svg"]).freeze
-    TRACK_COVER_URL   = ASSET_URL.call(/\/cover\/#{COUNTRY_ISO_CODE_GENERIC}\/\d{4}\/large/, ["jpg", "jpeg"]).freeze
+
+    TRACK_COVER_URL = IMAGE_SIZES[:track].each_with_object({}) do |image_size, hash|
+      url = ASSET_URL.call(/\/cover\/#{COUNTRY_ISO_CODE_GENERIC}\/\d{4}/, ["jpg", "jpeg", "png", "gif"], image_size.to_s)
+      hash[image_size] = url
+    end.freeze
+
+    USER_IMAGE_URL = IMAGE_SIZES[:user].each_with_object({}) do |image_size, hash|
+      url = ASSET_URL.call(/\/user\/\d+/, ["jpg", "jpeg", "png", "gif"], image_size.to_s)
+      hash[image_size] = url
+    end.freeze
 
     AUDIO_URL = lambda do |exts|
       exts = /(#{exts.join("|")})/

data/lib/radio5/utils.rb

@@ -9,17 +9,32 @@ module Radio5
 
     ASSET_HOST = "https://asset.radiooooo.com"
 
+    IMAGE_SIZES = {
+      track: %i[thumb small medium large],
+      user: %i[icon thumb small medium large]
+    }.freeze
+
     def parse_json(json_raw)
       JSON.parse(json_raw, symbolize_names: true)
     end
 
-    def parse_asset_url(hash, key, size: nil)
-      node = hash[key]
-
+    def parse_image_urls(node, entity:)
       if node
         path, filename = node.fetch_values(:path, :filename)
-        path << "#{size}/" if size
+        image_sizes = IMAGE_SIZES.fetch(entity)
+
+        image_sizes.each_with_object({}) do |image_size, hash|
+          image_size_path = "#{path}#{image_size}/"
+          image_url = create_asset_url(image_size_path, filename)
+
+          hash[image_size] = image_url
+        end
+      end
+    end
 
+    def parse_asset_url(node)
+      if node
+        path, filename = node.fetch_values(:path, :filename)
         create_asset_url(path, filename)
       end
     end
@@ -50,5 +65,13 @@ module Radio5
     def symbolize_mood(mood)
       MOODS_MAPPING.key(mood)
     end
+
+    def stringify_user_track_status(status)
+      USER_TRACK_STATUSES_MAPPING.fetch(status)
+    end
+
+    def symbolize_user_track_status(status)
+      USER_TRACK_STATUSES_MAPPING.key(status)
+    end
   end
 end

data/lib/radio5/validator.rb

@@ -20,63 +20,125 @@ module Radio5
       object.is_a?(Symbol) && MOODS_MAPPING.key?(object)
     end
 
+    def user_track_status?(object)
+      object.is_a?(Symbol) && USER_TRACK_STATUSES_MAPPING.key?(object)
+    end
+
+    def positive_number?(object)
+      object.is_a?(Integer) && object.positive?
+    end
+
+    def validate!
+      yield
+
+      true
+    end
+
+    def validate_user_id!(object)
+      validate! do
+        unless mongo_id?(object)
+          raise ArgumentError, "invalid user ID: #{object.inspect}"
+        end
+      end
+    end
+
     def validate_track_id!(object)
-      unless mongo_id?(object)
-        raise ArgumentError, "invalid track ID: #{object.inspect}"
+      validate! do
+        unless mongo_id?(object)
+          raise ArgumentError, "invalid track ID: #{object.inspect}"
+        end
       end
     end
 
     def validate_island_id!(object)
-      unless mongo_id?(object)
-        raise ArgumentError, "invalid island ID: #{object.inspect}"
+      validate! do
+        unless mongo_id?(object)
+          raise ArgumentError, "invalid island ID: #{object.inspect}"
+        end
       end
     end
 
     def validate_country_iso_codes!(iso_codes)
-      unless iso_codes.is_a?(Array)
-        raise ArgumentError, "country ISO codes should be an array"
-      end
-
-      iso_codes.each do |iso_code|
-        validate_country_iso_code!(iso_code)
+      validate! do
+        unless iso_codes.is_a?(Array)
+          raise ArgumentError, "country ISO codes should be an array: #{iso_codes.inspect}"
+        end
+
+        iso_codes.each do |iso_code|
+          validate_country_iso_code!(iso_code)
+        end
       end
     end
 
     def validate_country_iso_code!(object)
-      unless country_iso_code?(object)
-        raise ArgumentError, "invalid country ISO code: #{object.inspect}"
+      validate! do
+        unless country_iso_code?(object)
+          raise ArgumentError, "invalid country ISO code: #{object.inspect}"
+        end
       end
     end
 
     def validate_decades!(decades)
-      unless decades.is_a?(Array)
-        raise ArgumentError, "decades should be an array"
-      end
-
-      decades.each do |decade|
-        validate_decade!(decade)
+      validate! do
+        unless decades.is_a?(Array)
+          raise ArgumentError, "decades should be an array: #{decades.inspect}"
+        end
+
+        decades.each do |decade|
+          validate_decade!(decade)
+        end
       end
     end
 
     def validate_decade!(object)
-      unless decade?(object)
-        raise ArgumentError, "invalid decade: #{object.inspect}"
+      validate! do
+        unless decade?(object)
+          raise ArgumentError, "invalid decade: #{object.inspect}"
+        end
       end
     end
 
     def validate_moods!(moods)
-      unless moods.is_a?(Array)
-        raise ArgumentError, "moods should be an array"
+      validate! do
+        unless moods.is_a?(Array)
+          raise ArgumentError, "moods should be an array: #{moods.inspect}"
+        end
+
+        moods.each do |mood|
+          validate_mood!(mood)
+        end
       end
+    end
 
-      moods.each do |mood|
-        validate_mood!(mood)
+    def validate_mood!(object)
+      validate! do
+        unless mood?(object)
+          raise ArgumentError, "invalid mood: #{object.inspect}"
+        end
       end
     end
 
-    def validate_mood!(object)
-      unless mood?(object)
-        raise ArgumentError, "invalid mood: #{object.inspect}"
+    def validate_user_track_status!(object)
+      validate! do
+        unless user_track_status?(object)
+          raise ArgumentError, "invalid user track status: #{object.inspect}"
+        end
+      end
+    end
+
+    def validate_page_size!(object)
+      validate! do
+        unless positive_number?(object)
+          raise ArgumentError, "invalid page size: #{object.inspect}"
+        end
+      end
+    end
+
+    def validate_page_number!(object)
+      validate! do
+        unless positive_number?(object)
+          raise ArgumentError, "invalid page number: #{object.inspect}"
+        end
       end
     end
   end

data/lib/radio5/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Radio5
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/radio5.rb

@@ -22,4 +22,18 @@ module Radio5
   }.freeze
 
   MOODS = MOODS_MAPPING.keys.freeze
+
+  USER_TRACK_STATUSES_MAPPING = {
+    posted: "posted",
+    rejected: "rejected",
+    on_air: "onair",
+    confirmation: "confirmation",
+    duplicate: "duplicate",
+    deleted: "deleted",
+    broken: "broken"
+  }.freeze
+
+  USER_TRACK_STATUSES = USER_TRACK_STATUSES_MAPPING.keys.freeze
+
+  MAX_PAGE_SIZE = 1_000_000_000
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: radio5
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Dmytro Horoshko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-09 00:00:00.000000000 Z
+date: 2024-01-11 00:00:00.000000000 Z
 dependencies: []
 description: Adapter for Radiooooo private API.
 email: