napster 0.0.0 → 0.1.0

data/lib/napster/models/library_date_time.rb

@@ -0,0 +1,33 @@
+using StringHelper
+
+module Napster
+  module Models
+    # LibraryDateTime model
+    # Only used for /me/library/updated
+    class LibraryDateTime
+      ATTRIBUTES = [:date,
+                    :time_zone,
+                    :time_in_millis].freeze
+
+      ATTRIBUTES.each do |attribute|
+        attr_accessor attribute
+      end
+
+      attr_accessor :client
+
+      def initialize(arg)
+        @client = arg[:client] if arg[:client]
+        return unless arg[:data]
+        ATTRIBUTES.each do |attribute|
+          send("#{attribute}=", arg[:data][attribute.to_s.camel_case_lower])
+        end
+      end
+
+      def self.collection(arg)
+        arg[:data].map do |library_date_time|
+          LibraryDateTime.new(data: library_date_time, client: @client)
+        end
+      end
+    end
+  end
+end

data/lib/napster/models/member.rb

@@ -0,0 +1,124 @@
+using StringHelper
+
+module Napster
+  module Models
+    # Member model
+    class Member
+      ATTRIBUTES = [:type,
+                    :id,
+                    :real_name,
+                    :screen_name,
+                    :bio,
+                    :location,
+                    :genre,
+                    :visibility,
+                    :href,
+                    :favorite_albums_count,
+                    :favorite_artists_count,
+                    :favorite_tracks_count,
+                    :playlists_total_count,
+                    :playlists_published_count,
+                    :stations_count,
+                    :radio_count,
+                    :follower_count,
+                    :following_count,
+                    :avatar,
+                    :avatar_id,
+                    :default_avatar,
+                    :avatar_version].freeze
+
+      ATTRIBUTES.each do |attribute|
+        attr_accessor attribute
+      end
+
+      attr_accessor :client
+
+      def initialize(arg)
+        @client = arg[:client] if arg[:client]
+        return unless arg[:data]
+
+        ATTRIBUTES.each do |attribute|
+          send("#{attribute}=", arg[:data][attribute.to_s.camel_case_lower])
+        end
+      end
+
+      def self.collection(arg)
+        arg[:data].map do |member|
+          Member.new(data: member, client: @client)
+        end
+      end
+
+      # Top level methods
+
+      def find(arg)
+        response = @client.get("/members/#{arg}")
+        Member.new(data: response['members'].first, client: @client)
+      end
+
+      def screenname_available?(screenname)
+        response = @client.get("/screenname/#{screenname}")
+        response['screenName'].nil?
+      end
+
+      # TODO: .avatar
+
+      def playlists(params)
+        request_playlists(@id, params)
+      end
+
+      def playlists_for(guid, params)
+        request_playlists(guid, params)
+      end
+
+      def favorites(params)
+        request_favorites(@id, params)
+      end
+
+      def favorites_for(guid, params)
+        request_favorites(guid, params)
+      end
+
+      def favorite_playlists(params)
+        request_favorite_playlists(@id, params)
+      end
+
+      def favorite_playlists_for(guid, params)
+        request_favorite_playlists(guid, params)
+      end
+
+      def chart(params)
+        request_chart(@id, params)
+      end
+
+      def chart_for(guid, params)
+        request_chart(guid, params)
+      end
+
+      private
+
+      def request_playlists(guid, params)
+        options = { params: params }
+        response = @client.get("/members/#{guid}/library/playlists", options)
+        Playlist.collection(data: response['playlists'], client: @client)
+      end
+
+      def request_favorites(guid, params)
+        options = { params: params }
+        response = @client.get("/members/#{guid}/favorites", options)
+        Favorite.collection(data: response['favorites'], client: @client)
+      end
+
+      def request_favorite_playlists(guid, params)
+        options = { params: params }
+        response = @client.get("/members/#{guid}/favorites/playlists", options)
+        Playlist.collection(data: response['playlists'], client: @client)
+      end
+
+      def request_chart(guid, params)
+        options = { params: params }
+        response = @client.get("/members/#{guid}/charts", options)
+        Chart.collection(data: response['charts'], client: @client)
+      end
+    end
+  end
+end

data/lib/napster/models/playlist.rb

@@ -0,0 +1,279 @@
+using StringHelper
+
+module Napster
+  module Models
+    # Playlist model
+    class Playlist
+      ATTRIBUTES = [:type,
+                    :id,
+                    :name,
+                    :modified,
+                    :href,
+                    :privacy,
+                    :images,
+                    :description,
+                    :favorite_count,
+                    :free_play_compliant].freeze
+
+      ATTRIBUTES.each do |attribute|
+        attr_accessor attribute
+      end
+
+      attr_accessor :client
+
+      def initialize(arg)
+        @client = arg[:client] if arg[:client]
+        return unless arg[:data]
+
+        ATTRIBUTES.each do |attribute|
+          send("#{attribute}=", arg[:data][attribute.to_s.camel_case_lower])
+        end
+      end
+
+      def self.collection(arg)
+        arg[:data].map do |playlist|
+          Playlist.new(data: playlist, client: @client)
+        end
+      end
+
+      # Top level methods
+
+      def playlists_of_the_day(params)
+        response = @client.get('/playlists', params: params)
+        Playlist.collection(data: response['playlists'], client: @client)
+      end
+
+      def featured(params)
+        response = @client.get('/playlists/featured', params: params)
+        Playlist.collection(data: response['playlists'], client: @client)
+      end
+
+      def find(id)
+        e = 'Invalid playlist id'
+        raise ArgumentError, e unless Napster::Moniker.check(id, :playlist)
+
+        return authenticated_find(id) if @client.access_token
+
+        response = @client.get("/playlists/#{id}")
+        Playlist.new(data: response['playlists'].first, client: @client)
+      end
+
+      # Instance methods
+
+      def tracks(params)
+        return authenticated_tracks(params) if @client.access_token
+
+        hash = { params: params }
+        response = @client.get("/playlists/#{@id}/tracks", hash)
+        Track.collection(data: response['tracks'], client: @client)
+      end
+
+      def tags
+        return authenticated_tags if @client.access_token
+
+        response = @client.get("/playlists/#{@id}/tags")
+        Tag.collection(data: response['tags'], client: @client)
+      end
+
+      # /me
+
+      def all(params)
+        get_options = {
+          params: params,
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        response = @client.get('/me/library/playlists', get_options)
+        Playlist.collection(data: response['playlists'])
+      end
+
+      def authenticated_find(playlist_id)
+        path = "/me/library/playlists/#{playlist_id}"
+        get_options = {
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        response = @client.get(path, get_options)
+        return nil if response['playlists'].empty?
+
+        Playlist.new(data: response['playlists'].first, client: @client)
+      end
+
+      def authenticated_tracks(params)
+        path = "/me/library/playlists/#{@id}/tracks"
+        options = {
+          params: params,
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        response = @client.get(path, options)
+        return [] if response['tracks'].empty?
+
+        Track.collection(data: response['tracks'], client: @client)
+      end
+
+      def create(playlist_hash)
+        body = Oj.dump('playlists' => playlist_hash)
+        path = '/me/library/playlists'
+        options = {
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        response = @client.post(path, body, options)
+        Playlist.new(data: response['playlists'].first, client: @client)
+      end
+
+      def update(playlist_id, playlist_hash)
+        body = Oj.dump('playlists' => playlist_hash)
+        path = "/me/library/playlists/#{playlist_id}"
+        options = {
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        response = @client.put(path, body, options)
+        Playlist.new(data: response['playlists'].first, client: @client)
+      end
+
+      def delete(playlist_id)
+        path = "/me/library/playlists/#{playlist_id}"
+        options = {
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        @client.delete(path, options)
+      end
+
+      def set_private(playlist_id, boolean)
+        e = 'The argument should be a boolean value.'
+        raise ArgumentError, e unless [true, false].include?(boolean)
+
+        privacy_value = boolean ? 'private' : 'public'
+        body = Oj.dump('privacy' => privacy_value)
+        path = "/me/library/playlists/#{playlist_id}/privacy"
+        options = {
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        @client.put(path, body, options)
+      end
+
+      def add_tracks(playlist_id, tracks)
+        tracks = tracks.map { |track| { 'id' => track } }
+        body = Oj.dump('tracks' => tracks)
+        path = "/me/library/playlists/#{playlist_id}/tracks"
+        options = {
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        @client.post(path, body, options)
+      end
+
+      def authenticated_tags
+        return [] if @id
+        path = "/me/library/playlists/#{playlist_id}/tags"
+        options = {
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        response = @client.get(path, options)
+        return [] if response['tags']
+        Tag.collection(data: response['tags'], client: @client)
+      end
+
+      def recommended_tracks(playlist_id)
+        options = {
+          params: { playlistId: playlist_id },
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        response = @client.get('/me/recommendations/tracks', options)
+        Track.collection(data: response['tracks'], client: @client)
+      end
+
+      def uploaded_images(options)
+        return uploaded_images_with_size(options) if options.class == Fixnum
+        e = 'Playlist ID is missing.'
+        playlist_id = options[:id] ? options[:id] : @id
+        raise ArgumentError, e unless playlist_id
+
+        path = "/me/library/playlists/#{playlist_id}/images"
+        options = {
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        options[:params] = { size: options[:size] } if options[:size]
+        response = @client.get(path, options)
+        UploadedImage.collection(data: response['images'], client: @client)
+      end
+
+      def sourced_by(sourced, params)
+        sourced_error = 'sourced argument should be a string'
+        params_error = 'params argument should be a hash'
+        raise ArgumentError, sourced_error unless sourced.class == String
+        raise ArgumentError, params_error unless params.class == Hash
+
+        path = '/me/search/playlists'
+        options = {
+          params: params,
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        options[:params][:source] = sourced
+        response = @client.get(path, options)
+        Playlist.collection(data: response['playlists'], client: @client)
+      end
+
+      private
+
+      def uploaded_images_with_size(size)
+        path = "/me/library/playlists/#{@id}/images"
+        options = {
+          params: { size: size },
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        response = @client.get(path, options)
+        UploadedImage.collection(data: response['images'], client: @client)
+      end
+    end
+  end
+end

data/lib/napster/models/profile.rb

@@ -0,0 +1,75 @@
+using StringHelper
+
+module Napster
+  module Models
+    # Profile model
+    class Profile
+      ATTRIBUTES = [:id,
+                    :real_name,
+                    :screen_name,
+                    :bio,
+                    :location,
+                    :gender,
+                    :visibility,
+                    :type,
+                    :href,
+                    :favorite_albums_count,
+                    :favorite_artists_count,
+                    :favorite_tracks_count,
+                    :playlists_total_count,
+                    :playlists_published_count,
+                    :stations_count,
+                    :radio_count,
+                    :follower_count,
+                    :following_count,
+                    :avatar,
+                    :avatar_id,
+                    :default_avatar,
+                    :avatar_version,
+                    :links].freeze
+
+      ATTRIBUTES.each do |attribute|
+        attr_accessor attribute
+      end
+
+      attr_accessor :client
+
+      def initialize(arg)
+        @client = arg[:client] if arg[:client]
+        return unless arg[:data]
+        ATTRIBUTES.each do |attribute|
+          send("#{attribute}=", arg[:data][attribute.to_s.camel_case_lower])
+        end
+      end
+
+      def self.collection(arg)
+        arg[:data].map do |profile|
+          Profile.new(data: profile, client: @client)
+        end
+      end
+
+      def get
+        get_options = {
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        response = @client.get('/me', get_options)
+        Profile.new(data: response['me'], client: @client)
+      end
+
+      def update(body)
+        put_options = {
+          headers: {
+            Authorization: 'Bearer ' + @client.access_token,
+            'Content-Type' => 'application/json',
+            'Accept-Version' => '2.0.0'
+          }
+        }
+        @client.put('/me', Oj.dump(body), put_options)
+      end
+    end
+  end
+end