7digital 0.0.2 → 0.0.5

data/lib/sevendigital/digestion_tract/pager_digestor.rb

@@ -1,6 +1,6 @@
 module Sevendigital
 
-  class PagerDigestor < Digestor
+  class PagerDigestor < Digestor # :nodoc:
 
     def default_element_name; :results end
     def default_list_element_name; nil end

data/lib/sevendigital/digestion_tract/price_digestor.rb

@@ -1,7 +1,7 @@
 require 'rational'
 module Sevendigital
 
-  class PriceDigestor < Digestor
+  class PriceDigestor < Digestor # :nodoc:
 
     def default_element_name; :price end
     def default_list_element_name; nil end
@@ -11,11 +11,11 @@ module Sevendigital
         price = Sevendigital::Price.new()
         price.currency_code = price_proxy.currency.code.to_s.upcase.to_sym
         price.currency_symbol= price_proxy.currency.value
-        price.value= price_proxy.value.value.to_f
+        price.value= price_proxy.value.value.to_f if !price_proxy.value.value.to_s.empty?
         price.formatted_price= price_proxy.formatted_price.value
         price.rrp= price_proxy.rrp.value.to_f if price_proxy.rrp
         price.formatted_rrp= price_proxy.formatted_rrp.value if price_proxy.formatted_rrp
-        price.on_sale = price_proxy.on_sale.value.to_s.downcase == "true"
+        price.on_sale = price_proxy.on_sale.value.to_s.downcase == "true" if price_proxy.on_sale
 
         return price
       end

data/lib/sevendigital/digestion_tract/release_digestor.rb

@@ -2,7 +2,7 @@ module Sevendigital
 
   require 'date'
 
-  class ReleaseDigestor < Digestor
+  class ReleaseDigestor < Digestor # :nodoc:
     
     def default_element_name; :release end
     def default_list_element_name; :releases end

data/lib/sevendigital/digestion_tract/tag_digestor.rb

@@ -0,0 +1,22 @@
+module Sevendigital
+
+  class TagDigestor < Digestor # :nodoc:
+
+    def default_element_name; :tag end
+    def default_list_element_name; :tags end
+    
+    def from_proxy(tag_proxy)
+      make_sure_not_eating_nil(tag_proxy)
+
+      tag = Tag.new()
+      tag.id = tag_proxy.id.to_s
+      tag.text = tag_proxy.text.value.to_s
+      tag.url = tag_proxy.url.value.to_s if value_present?(tag_proxy.url)
+      tag.count = tag_proxy.count.value.to_i  #if value_present?(tag_proxy.count)
+
+      return tag
+    end
+
+  end
+
+end

data/lib/sevendigital/digestion_tract/track_digestor.rb

@@ -1,6 +1,6 @@
 module Sevendigital
 
-  class TrackDigestor < Digestor
+  class TrackDigestor < Digestor # :nodoc:
 
     def default_element_name; :track end
     def default_list_element_name; :tracks end

data/lib/sevendigital/management/artist_manager.rb

@@ -2,43 +2,80 @@ require "peachy"
 
 module Sevendigital
 
+  # provides access to Artist related API methods (artist/*)
   class ArtistManager < Manager
 
-     def get_details(id, options={})
-        api_request = Sevendigital::ApiRequest.new("artist/details", {:artistId => id}, options)
-        api_response = @api_client.operator.call_api(api_request)
-        @api_client.artist_digestor.from_xml(api_response.content.artist)
-      end
-
-      def get_releases(id, options={})
-        api_request = Sevendigital::ApiRequest.new("artist/releases", {:artistId => id}, options)
-        api_response = @api_client.operator.call_api(api_request)
-        @api_client.release_digestor.list_from_xml(api_response.content.releases)
-      end
+    # calls *artist/details* API method and returns Artist with populated details
+    #
+    # <tt>artist_id</tt>:: artist ID
+    # <tt>options</tt>:: optional hash of additional API parameters, e.g. {page_size => 50}, etc
+    def get_details(artist_id, options={})
+      api_response = @api_client.make_api_request("artist/details", {:artistId => artist_id}, options)
+      @api_client.artist_digestor.from_xml(api_response.content.artist)
+    end
+
+    # calls *artist/releases* API method and returns Release array
+    #
+    # <tt>artist_id</tt>:: artist ID
+    # <tt>options</tt>:: optional hash of additional API parameters, e.g. {page_size => 50}, etc
+    def get_releases(artist_id, options={})
+      api_response = @api_client.make_api_request("artist/releases", {:artistId => artist_id}, options)
+      @api_client.release_digestor.list_from_xml(api_response.content.releases)
+    end
       
-      def get_top_tracks(id, options={})
-        api_request = Sevendigital::ApiRequest.new("artist/toptracks", {:artistId => id}, options)
-        api_response = @api_client.operator.call_api(api_request)
-        @api_client.track_digestor.list_from_xml(api_response.content.tracks)
-      end
-
-      def get_similar(id, options={})
-        api_request = Sevendigital::ApiRequest.new("artist/similar", {:artistId => id}, options)
-        api_response = @api_client.operator.call_api(api_request)
-        @api_client.artist_digestor.list_from_xml(api_response.content.artists)
-      end
-
-      def get_top_by_tag(tags, options={})
-        api_request = Sevendigital::ApiRequest.new("artist/byTag/top", {:tags => tags}, options)
-        api_response = @api_client.operator.call_api(api_request)
-        @api_client.artist_digestor.nested_list_from_xml(api_response.content.tagged_results, :tagged_item, :tagged_results)
-      end
-
-       def search(query, options={})
-         api_request = Sevendigital::ApiRequest.new("artist/search", {:q => query}, options)
-         api_response = @api_client.operator.call_api(api_request)
-         @api_client.artist_digestor.nested_list_from_xml(api_response.content.search_results, :search_result, :search_results)
-       end
+    # calls *artist/toptracks* API method and returns Track array
+    #
+    # <tt>artist_id</tt>:: artist ID
+    # <tt>options</tt>:: optional hash of additional API parameters, e.g. {page_size => 50}, etc
+      def get_top_tracks(artist_id, options={})
+      api_response = @api_client.make_api_request("artist/topTracks", {:artistId => artist_id}, options)
+      @api_client.track_digestor.list_from_xml(api_response.content.tracks)
+    end
+
+    # calls *artist/similar* API method and returns Artist array
+    #
+    # <tt>artist_id</tt>:: artist ID
+    # <tt>options</tt>:: optional hash of additional API parameters, e.g. {page_size => 50}, etc
+    def get_similar(artist_id, options={})
+      api_response = @api_client.make_api_request("artist/similar", {:artistId => artist_id}, options)
+      @api_client.artist_digestor.list_from_xml(api_response.content.artists)
+    end
+
+    # calls *artist/byTag/top* API method and returns Artist array
+    #
+    # <tt>tags</tt>:: string containing comma separated list of tags
+    # <tt>options</tt>:: optional hash of additional API parameters, e.g. {page_size => 50}, etc
+    def get_top_by_tag(tags, options={})
+      api_response = @api_client.make_api_request("artist/byTag/top", {:tags => tags}, options)
+      @api_client.artist_digestor.nested_list_from_xml(api_response.content.tagged_results, :tagged_item, :tagged_results)
+    end
+
+    # calls *artist/search* API method and returns Artist array
+    #
+    # <tt>query</tt>:: string containing the search query
+    # <tt>options</tt>:: optional hash of additional API parameters, e.g. {page_size => 50}, etc
+    def search(query, options={})
+     api_response = @api_client.make_api_request("artist/search", {:q => query}, options)
+     @api_client.artist_digestor.nested_list_from_xml(api_response.content.search_results, :search_result, :search_results)
+    end
+
+    # calls *artist/browse* API method and returns Artist array
+    #
+    # <tt>letter</tt>:: string containing the search query
+    # <tt>options</tt>:: optional hash of additional API parameters, e.g. {page_size => 50}, etc
+    def browse(letter, options={})
+     api_response = @api_client.make_api_request("artist/browse", {:letter => letter}, options)
+     @api_client.artist_digestor.list_from_xml(api_response.content.artists)
+    end
+
+    # calls *artist/chart* API method and returns Artist array
+    #
+    # <tt>options</tt>:: optional hash of additional API parameters, e.g. {page_size => 50}, etc
+    def get_chart(options={})
+     api_response = @api_client.make_api_request("artist/chart", {}, options)
+     @api_client.chart_item_digestor.list_from_xml(api_response.content.chart)
+    end
+
 
   end
 

data/lib/sevendigital/management/basket_manager.rb

@@ -0,0 +1,29 @@
+module Sevendigital
+
+  class BasketManager < Manager
+
+     def get(basket_id, options={})
+        api_response = @api_client.make_api_request("basket", {:basketId => basket_id}, options)
+        @api_client.basket_digestor.from_xml(api_response.content.basket)
+      end
+
+      def create(options={})
+        api_response = @api_client.make_api_request("basket/create", {}, options)
+        @api_client.basket_digestor.from_xml(api_response.content.basket)
+      end
+
+      def add_item(basket_id, release_id, track_id=nil, options={})
+        api_response = @api_client.make_api_request("basket/addItem", {:basketId => basket_id, :releaseId => release_id, :trackId => track_id}, options)
+        @api_client.basket_digestor.from_xml(api_response.content.basket)
+      end
+
+
+      def remove_item(basket_id, item_id, options={})
+        api_response = @api_client.make_api_request("basket/removeItem", {:basketId => basket_id, :itemId => item_id}, options)
+        @api_client.basket_digestor.from_xml(api_response.content.basket)
+      end
+
+
+  end
+
+end

data/lib/sevendigital/management/manager.rb

@@ -1,6 +1,6 @@
 module Sevendigital
 
-  class Manager
+  class Manager # :nodoc:
 
     def initialize(api_client)
       @api_client =  api_client

data/lib/sevendigital/management/oauth_manager.rb

@@ -0,0 +1,23 @@
+module Sevendigital
+
+  class OAuthManager < Manager
+
+    def get_request_token
+      api_response = @api_client.make_signed_api_request("oauth/requestToken", {})
+      @api_client.oauth_request_token_digestor.from_xml(api_response.content.oauth_request_token, :oauth_request_token)
+    end
+
+    def get_access_token(request_token)
+      api_response = @api_client.make_signed_api_request("oauth/accessToken", {}, {}, request_token)
+      @api_client.oauth_access_token_digestor.from_xml(api_response.content.oauth_access_token, :oauth_access_token)
+    end
+
+    def authorise_request_token(username, password, request_token)
+      api_response = @api_client.make_signed_api_request("oauth/requestToken/authorise", \
+        {:username => username, :password => password, :token => request_token.token})
+      api_response.ok?
+    end
+
+  end
+
+end

data/lib/sevendigital/management/release_manager.rb

@@ -5,21 +5,18 @@ module Sevendigital
   class ReleaseManager < Manager
 
     def get_details(release_id, options = {})
-      api_request = Sevendigital::ApiRequest.new("release/details", {:releaseId => release_id}, options)
-      api_response = @api_client.operator.call_api(api_request)
+      api_response = @api_client.make_api_request("release/details", {:releaseId => release_id}, options)
       @api_client.release_digestor.from_xml(api_response.content.release)
     end
 
     def get_tracks(release_id, options = {})
       options[:page_size] ||= 100
-      api_request = Sevendigital::ApiRequest.new("release/tracks", {:releaseId => release_id}, options)
-      api_response = @api_client.operator.call_api(api_request)
+      api_response = @api_client.make_api_request("release/tracks", {:releaseId => release_id}, options)
       @api_client.track_digestor.list_from_xml(api_response.content.tracks)
     end
 
     def get_chart(options={})
-      api_request = Sevendigital::ApiRequest.new("release/chart", {}, options)
-      api_response = @api_client.operator.call_api(api_request)
+      api_response = @api_client.make_api_request("release/chart", {}, options)
       @api_client.chart_item_digestor.list_from_xml(api_response.content.chart)
     end
 
@@ -28,28 +25,24 @@ module Sevendigital
       parameters[:fromDate] = from_date.strftime("%Y%m%d") if from_date
       parameters[:toDate] = to_date.strftime("%Y%m%d") if to_date
 
-      api_request = Sevendigital::ApiRequest.new("release/byDate", parameters, options)
-      api_response = @api_client.operator.call_api(api_request)
+      api_response = @api_client.make_api_request("release/byDate", parameters, options)
       @api_client.release_digestor.list_from_xml(api_response.content.releases)
     end
 
     def get_recommendations(release_id, options = {})
-      api_request = Sevendigital::ApiRequest.new("release/recommend", {:releaseId => release_id}, options)
-      api_response = @api_client.operator.call_api(api_request)
+      api_response = @api_client.make_api_request("release/recommend", {:releaseId => release_id}, options)
       @api_client.release_digestor.nested_list_from_xml(api_response.content.recommendations, :recommended_item, :recommendations)
     end
 
 
     def get_top_by_tag(tags, options = {})
-      api_request = Sevendigital::ApiRequest.new("release/byTag/top", {:tags => tags}, options)
-      api_response = @api_client.operator.call_api(api_request)
+      api_response = @api_client.make_api_request("release/byTag/top", {:tags => tags}, options)
       @api_client.release_digestor.nested_list_from_xml( \
       api_response.content.tagged_results, :tagged_item, :tagged_results )
     end
 
     def search(query, options={})
-      api_request = Sevendigital::ApiRequest.new("release/search", {:q => query}, options)
-      api_response = @api_client.operator.call_api(api_request)
+      api_response = @api_client.make_api_request("release/search", {:q => query}, options)
       @api_client.release_digestor.nested_list_from_xml(api_response.content.search_results, :search_result, :search_results)
     end
 

data/lib/sevendigital/management/tag_manager.rb

@@ -0,0 +1,11 @@
+module Sevendigital
+
+  class TagManager < Manager
+
+    def get_tag_list(options={})
+      api_response = @api_client.make_api_request("tag", {}, options)
+      @api_client.tag_digestor.list_from_xml(api_response.content.tags)
+    end
+
+  end
+end

data/lib/sevendigital/management/track_manager.rb

@@ -2,28 +2,28 @@ module Sevendigital
 
   class TrackManager < Manager
 
-    def get_details(id)
-      api_request = Sevendigital::ApiRequest.new("track/details", {:trackId => id})
-      api_response = @api_client.operator.call_api(api_request)
+    def get_details(id, options={})
+      api_response = @api_client.make_api_request("track/details", {:trackId => id}, options)
       @api_client.track_digestor.from_xml(api_response.content.track)
     end
 
+    def get_details_from_release(track_id, release_id, options={})
+      @api_client.release.get_tracks(release_id, options).find {|track| track.id = track_id}
+    end
+
     def get_chart(options={})
-      api_request = Sevendigital::ApiRequest.new("track/chart", {}, options)
-      api_response = @api_client.operator.call_api(api_request)
+      api_response = @api_client.make_api_request("track/chart", {}, options)
       @api_client.chart_item_digestor.list_from_xml(api_response.content.chart)
     end
 
     def build_preview_url(id, options={})
-      api_request = Sevendigital::ApiRequest.new("track/preview", {:trackId => id}, options)
+      api_request = @api_client.create_api_request("track/preview", {:trackId => id}, options)
       @api_client.operator.create_request_uri(api_request)
     end
 
     def search(query, options={})
-      api_request = Sevendigital::ApiRequest.new("track/search", {:q => query}, options)
-      api_response = @api_client.operator.call_api(api_request)
+      api_response = @api_client.make_api_request("track/search", {:q => query}, options)
       @api_client.track_digestor.nested_list_from_xml(api_response.content.search_results, :search_result, :search_results)
     end
-
   end
 end

data/lib/sevendigital/management/user_manager.rb

@@ -0,0 +1,51 @@
+module Sevendigital
+
+  class UserManager < Manager
+
+    def login(access_token)
+      raise Sevendigital::SevendigitalError if !access_token.kind_of? OAuth::AccessToken
+      user = Sevendigital::User.new(@api_client)
+      user.oauth_access_token = access_token
+      user
+    end
+
+    def authenticate(email, password)
+      request_token = @api_client.oauth.get_request_token
+      return nil unless @api_client.oauth.authorise_request_token(email, password, request_token)
+      user = Sevendigital::User.new(@api_client)
+      user.oauth_access_token = @api_client.oauth.get_access_token(request_token)
+      user
+    end
+
+    def get_locker(token, options={})
+      api_response = @api_client.make_signed_api_request("user/locker", {}, {}, token)
+      @locker = @api_client.locker_digestor.from_xml(api_response.content.locker)
+    end
+
+    def purchase(release_id, track_id, price, token, options={})
+      api_response = @api_client.make_signed_api_request("user/purchase/item", \
+        {:releaseId => release_id, :trackId => track_id, :price => price}, options, token)
+      @api_client.locker_digestor.from_xml(api_response.content.purchase)
+    end
+
+    def get_stream_track_url(release_id, track_id, token, options={})
+        api_request = @api_client.create_api_request("user/streamtrack", {:releaseId => release_id, :trackId => track_id}, options)
+        api_request.api_service = :media
+        api_request.require_signature
+        api_request.token = token
+        @api_client.operator.get_request_uri(api_request)
+    end
+
+    def get_add_card_url(return_url, token, options={})
+        api_request = @api_client.create_api_request("payment/addcard", {:returnUrl => return_url}, options)
+        api_request.api_service = :account
+        api_request.require_signature
+        api_request.require_secure_connection
+        api_request.token = token
+        @api_client.operator.get_request_uri(api_request)
+    end
+
+
+  end
+
+end

data/lib/sevendigital/model/api_response.rb

@@ -1,24 +1,40 @@
 module Sevendigital
 
+  #Holds the complete API response
   class ApiResponse
 
-    attr_accessor :error_code, :error_message, :content
+    attr_accessor :error_code, :error_message, :content, :headers
 
+    #True if no API error has been returned
     def ok?
       return (@error_code == 0 && !@content.nil?)
     end
 
     def _dump(depth)
-      Marshal.dump([@error_code, @error_message, @content.to_s])
+      Marshal.dump([@error_code, @error_message, @headers, @content.to_s])
     end
     
     def self._load(properties)
       response = ApiResponse.new
-      response.error_code, response.error_message, content_xml = Marshal.load(properties)
+      response.error_code, response.error_message, response.headers, content_xml = Marshal.load(properties)
       response.content = Peachy::Proxy.new(content_xml).response
       response
     end
 
+    #Returns true if the response has been retrieved from cache but has since expired
+    def out_of_date?(current_time=nil)
+      return true if @headers.nil? || @headers["Date"].nil? || @headers["cache-control"].nil?
+      return true if  !(@headers["cache-control"] =~ /max-age=([0-9]+)/)
+      current_time ||= Time.now.utc
+      response_time = Time.parse(@headers["Date"])
+      max_age = /max-age=([0-9]+)/.match(@headers["cache-control"])[1].to_i
+      response_time + max_age < current_time
+    end
+
+
+  def response_cacheable?
+    return true
+  end
 
   end