napster 0.0.0 → 0.1.0

data/lib/napster.rb

@@ -1,5 +1,28 @@
-require "napster/version"
+require 'faraday'
+require 'oj'
 
-module Napster
-  # Your code goes here...
-end
+require 'string_helper'
+require 'napster/client'
+require 'napster/me'
+require 'napster/moniker'
+require 'napster/response_error'
+require 'napster/request'
+require 'napster/version'
+
+# Models
+require 'napster/models/artist'
+require 'napster/models/album'
+require 'napster/models/chart'
+require 'napster/models/content'
+require 'napster/models/follower'
+require 'napster/models/following'
+require 'napster/models/favorite'
+require 'napster/models/favorite_status'
+require 'napster/models/library'
+require 'napster/models/library_date_time'
+require 'napster/models/member'
+require 'napster/models/playlist'
+require 'napster/models/profile'
+require 'napster/models/tag'
+require 'napster/models/track'
+require 'napster/models/uploaded_image'

data/lib/napster/client.rb

@@ -0,0 +1,276 @@
+module Napster
+  # The Client class implements a client object that prepares
+  # information such as api_key, api_secret, and :redirect_uri
+  # needed to call Napster API.
+  class Client
+    MODELS_LIST = %w(artist album track genre member playlist tag
+                     station radio favorite).freeze
+    AUTH_METHODS = [:password_grant, :oauth2].freeze
+
+    attr_accessor :api_key,
+                  :api_secret,
+                  :redirect_uri,
+                  :username,
+                  :password,
+                  :state,
+                  :auth_code,
+                  :access_token,
+                  :refresh_token,
+                  :expires_in,
+                  :request
+
+    # Instantiate a client object
+    # @note request attribute is always overwritten by Napster::Request
+    #   object.
+    # @param options [Hash] Required options are :api_key and :api_secret
+    def initialize(options)
+      options.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
+
+      request_hash = {
+        api_key: @api_key,
+        api_secret: @api_secret
+      }
+      @request = Napster::Request.new(request_hash)
+      authenticate_client
+      set_models
+    end
+
+    # Make a post request to Napster API
+    # @param path [String] API path
+    # @param body [Hash] Body for the post request
+    # @param options [Hash] Faraday adapter options
+    # @return [Hash] parsed response from Napster API
+    def post(path, body = {}, options = {})
+      validate_request(path, options)
+      raw_response = @request.faraday.post do |req|
+        req.url path, options[:params]
+        req.body = body
+        req.headers['apikey'] = @api_key
+        if options[:headers]
+          options[:headers].each do |key, value|
+            req.headers[key] = value
+          end
+        end
+      end
+      handle_response(raw_response)
+    end
+
+    # Make a get request to Napster API
+    # @param path [String] API path
+    # @param options [Hash] Faraday adapter options accepting
+    #   headers
+    # @return [Hash] parsed response from Napster API
+    def get(path, options = {})
+      validate_request(path, options)
+      raw_response = @request.faraday.get do |req|
+        req.url path, options[:params]
+        req.headers['apikey'] = @api_key
+        if options[:headers]
+          options[:headers].each do |key, value|
+            req.headers[key] = value
+          end
+        end
+      end
+      handle_response(raw_response)
+    end
+
+    # Make a put request to Napster API
+    # @param path [String] API path
+    # @param body [Hash] Body for the put request
+    # @param options [Hash] Faraday apapter options accepting
+    #   headers, params
+    # @return [Hash] parsed response from Napster API
+    def put(path, body = {}, options = {})
+      validate_request(path, options)
+      raw_response = @request.faraday.put do |req|
+        req.url path, options[:params]
+        req.body = body
+        req.headers['apikey'] = @api_key
+        if options[:headers]
+          options[:headers].each do |key, value|
+            req.headers[key] = value
+          end
+        end
+      end
+      handle_response(raw_response)
+    end
+
+    # Make a delete request to Napster API
+    # @param path [String] API path
+    # @param options [Hash] Faraday apapter options accepting
+    #   headers, params
+    # @return [Hash] parsed response from Napster API
+    def delete(path, options = {})
+      validate_request(path, options)
+      raw_response = @request.faraday.delete do |req|
+        req.url path, options[:params]
+        req.headers['apikey'] = @api_key
+        if options[:headers]
+          options[:headers].each do |key, value|
+            req.headers[key] = value
+          end
+        end
+      end
+      handle_response(raw_response)
+    end
+
+    # Smarter method for authentication via password_grant or oauth2
+    # @return [Client]
+    def connect
+      return authenticate(:password_grant) if authenticate_via_password_grant?
+      return authenticate(:oauth2) if authenticate_via_oauth2?
+      raise ArgumentError
+    end
+
+    # Main method for authenticating against Napster API
+    # @param auth_method [Symbol] authentication methods that are
+    #   :password_grant or :oauth2
+    # @return [Hash] response from Napster API
+    def authenticate(auth_method)
+      validate_authenticate(auth_method)
+
+      return auth_password_grant if auth_method == :password_grant
+      return auth_oauth2 if auth_method == :oauth2
+    end
+
+    # Get URL for OAuth2 authentication flow
+    # @return [String] OAuth2 authentication URL
+    def authentication_url
+      validate_authentication_url
+      query_params = {
+        client_id: @api_key,
+        redirect_uri: @redirect_uri,
+        response_type: 'code'
+      }
+      query_params[:state] = @state if @state
+      query_params_string = URI.encode_www_form(query_params)
+      Napster::Request::HOST_URL + '/oauth/authorize?' + query_params_string
+    end
+
+    # Include Me module for calling authenticated methods
+    def me
+      Napster::Me.new(self)
+    end
+
+    private
+
+    # Helper method for .new, choose authentication method, and authenticate
+    # @return [Client] Authenticated client
+    def authenticate_client
+      return authenticate(:password_grant) if authenticate_via_password_grant?
+      self
+    end
+
+    # Helper method for #authenticate_client, check if password_grant auth is
+    #   possible with current attributes.
+    # @return [Boolean]
+    def authenticate_via_password_grant?
+      @api_key && @api_secret && @username && @password
+    end
+
+    def authenticate_via_oauth2?
+      @api_key && @api_secret && @redirect_uri && @auth_code
+    end
+
+    def validate_request(path, options)
+      raise ArgumentError, 'path is missing' unless path
+      raise ArgumentError, 'options should be a hash' unless options.is_a?(Hash)
+      if options[:headers] && !options[:headers].is_a?(Hash)
+        raise ArgumentError, 'options[:headers] should be a hash'
+      end
+    end
+
+    def validate_authenticate(auth_method)
+      unless auth_method.is_a?(Symbol)
+        err = 'Authentication method must be passed as a symbol'
+        raise ArgumentError, err
+      end
+
+      unless AUTH_METHODS.include?(auth_method)
+        err = "Wrong authentication method. Valid methods are #{AUTH_METHODS}"
+        raise ArgumentError, err
+      end
+    end
+
+    def auth_password_grant
+      validate_auth_password_grant
+      body = post('/oauth/token',
+                  auth_password_grant_post_body,
+                  auth_password_grant_post_options)
+      @access_token = body['access_token']
+      @refresh_token = body['refresh_token']
+      @expires_in = body['expires_in']
+
+      self
+    end
+
+    def auth_password_grant_post_body
+      {
+        response_type: 'code',
+        grant_type: 'password',
+        username: @username,
+        password: @password
+      }
+    end
+
+    def auth_password_grant_post_options
+      basic_auth = Faraday::Request::BasicAuthentication.header(@api_key,
+                                                                @api_secret)
+      { headers: { Authorization: basic_auth } }
+    end
+
+    def validate_auth_password_grant
+      raise 'The client is missing username' unless @username
+      raise 'The client is missing password' unless @password
+    end
+
+    def auth_oauth2
+      validate_auth_oauth2
+      response_body = post('/oauth/access_token', auth_oauth2_post_body, {})
+      @access_token = response_body['access_token']
+      @refresh_token = response_body['refresh_token']
+      @expires_in = response_body['expires_in']
+      self
+    end
+
+    def auth_oauth2_post_body
+      {
+        client_id: @api_key,
+        client_secret: @api_secret,
+        response_type: 'code',
+        grant_type: 'authorization_code',
+        code: @auth_code,
+        redirect_uri: @redirect_uri
+      }
+    end
+
+    def validate_auth_oauth2
+      raise 'The client is missing redirect_uri' unless @redirect_uri
+      raise 'The client is missing auth_code' unless @auth_code
+    end
+
+    def validate_authentication_url
+      raise 'The client is missing redirect_uri' unless @redirect_uri
+    end
+
+    def set_models
+      MODELS_LIST.each do |model|
+        define_singleton_method("#{model}s") do
+          Object.const_get(model_class_name(model)).new(client: self)
+        end
+      end
+      self
+    end
+
+    def model_class_name(model)
+      "Napster::Models::#{model.capitalize}"
+    end
+
+    def handle_response(response)
+      raise ResponseError.new(response) if response && !response.success?
+      Oj.load(response.body)
+    end
+  end
+end

data/lib/napster/me.rb

@@ -0,0 +1,58 @@
+module Napster
+  # Authenticated endpoints under /me namespace
+  class Me
+    MODELS_LIST = %w(favorite playlist follower tag).freeze
+    attr_accessor :client
+
+    def initialize(client)
+      validate_access_token(client)
+      @client = client
+      set_models
+    end
+
+    def listening_history(params)
+      get_options = {
+        params: params,
+        headers: {
+          Authorization: 'Bearer ' + @client.access_token,
+          'Content-Type' => 'application/json',
+          'Accept-Version' => '2.0.0'
+        }
+      }
+      response = @client.get('/me/listens', get_options)
+      Napster::Models::Track
+        .collection(data: response['tracks'], client: @client)
+    end
+
+    def library
+      Napster::Models::Library.new(client: @client)
+    end
+
+    def profile
+      Napster::Models::Profile.new(client: @client)
+    end
+
+    def following
+      Napster::Models::Following.new(client: @client)
+    end
+
+    private
+
+    def validate_access_token(client)
+      raise 'The client is missing access_token' unless client.access_token
+    end
+
+    def set_models
+      MODELS_LIST.each do |model|
+        define_singleton_method("#{model}s") do
+          Object.const_get(model_class_name(model)).new(client: @client)
+        end
+      end
+      self
+    end
+
+    def model_class_name(model)
+      "Napster::Models::#{model.capitalize}"
+    end
+  end
+end

data/lib/napster/models/album.rb

@@ -0,0 +1,97 @@
+using StringHelper
+
+module Napster
+  module Models
+    # Album model
+    class Album
+      ATTRIBUTES = [:type,
+                    :id,
+                    :upc,
+                    :shortcut,
+                    :href,
+                    :name,
+                    :released,
+                    :originally_released,
+                    :label,
+                    :copyright,
+                    :tags,
+                    :disc_count,
+                    :track_count,
+                    :explicit,
+                    :single,
+                    :account_partner,
+                    :artist_name,
+                    :contributing_artists].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 |album|
+          Album.new(data: album, client: @client)
+        end
+      end
+
+      # Top level methods
+
+      def new_releases(params)
+        response = @client.get('/albums/new', params: params)
+        Album.collection(data: response['albums'], client: @client)
+      end
+
+      def staff_picks(params)
+        response = @client.get('/albums/picks', params: params)
+        Album.collection(data: response['albums'], client: @client)
+      end
+
+      def top(params)
+        response = @client.get('/albums/top', params: params)
+        Album.collection(data: response['albums'], client: @client)
+      end
+
+      def find(arg)
+        return find_by_id(arg) if Napster::Moniker.check(arg, :album)
+        find_by_name(arg)
+      end
+
+      def find_by_id(id)
+        response = @client.get("/albums/#{id}")
+        Album.new(data: response['albums'].first, client: @client)
+      end
+
+      def find_all_by_name(name)
+        options = {
+          params: {
+            q: name,
+            type: 'album'
+          }
+        }
+        response = @client.get('/search', options)
+        Album.collection(data: response['data'])
+      end
+
+      def find_by_name(name)
+        find_all_by_name(name).first
+      end
+
+      # Instance methods
+
+      def tracks(params)
+        response = @client.get("/albums/#{@id}/tracks", params: params)
+        Track.collection(data: response['tracks'], client: @client)
+      end
+    end
+  end
+end