bol 0.0.1.beta

data/lib/bol/parsers/refinements.rb

@@ -0,0 +1,24 @@
+module Bol
+  module Parsers
+    class Refinements < Parser
+      def xpath
+        '*/RefinementGroup'
+      end
+
+      def parse_object(el)
+        RefinementGroup.new.tap do |category|
+          category.name  = el.elements['Name'].text.strip
+          category.id    = el.elements['Id'].text.strip
+          category.refinements = []
+          el.elements.each('Refinement') do |e|
+            category.refinements << Refinement.new.tap { |r|
+              r.name  = e.elements['Name'].text.strip
+              r.id    = e.elements['Id'].text.strip
+              r.count = e.elements['ProductCount'].text.strip
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bol/product.rb

@@ -0,0 +1,51 @@
+require 'cgi'
+
+module Bol
+  class Product
+    def self.find(id)
+      Requests::Product.new(id, Query.new(0)).proxy.all.first
+    end
+
+    attr_reader :attributes
+
+    def initialize
+      @attributes = {}
+    end
+
+    def [](key)
+      @attributes[key]
+    end
+
+    def []=(key, value)
+      @attributes[key] = value
+    end
+
+    def cover(kind = :medium)
+      attributes[:cover].fetch(kind)
+    end
+
+    def referral_url(site_id)
+      format = "http://partnerprogramma.bol.com/click/click?p=1&t=url&s=%s&url=%s&f=API&subid=%s&name=%s"
+      format % [
+        site_id,
+        attributes.fetch(:url),
+        attributes.fetch(:id),
+        attributes.fetch(:title),
+      ].map { |p| CGI.escape(p) }
+    end
+
+    def method_missing(name, *args)
+      return super unless attributes.keys.include?(name)
+      if name =~ /=$/
+        attributes[name] = *args
+      else
+        attributes[name]
+      end
+    end
+
+    def respond_to?(name)
+      super or attributes.keys.include?(name) or
+        attributes.keys.include?(name.to_s.sub(/=$/, '').to_sym)
+    end
+  end
+end

data/lib/bol/proxy.rb

@@ -0,0 +1,37 @@
+module Bol
+  class Proxy
+    include Enumerable
+
+    attr_reader :request, :parser
+
+    def initialize(request, parser)
+      @request = request
+      @parser  = parser
+    end
+
+    def each
+      all.each { |a| yield a }
+    end
+
+    def all
+      @all ||= parser.objects
+    end
+
+    def query
+      request.query
+    end
+
+    %w[category_id= category_id].each do |method|
+      define_method method do |*args|
+        query.send method, *args
+      end
+    end
+
+    %w[order page offset limit].each do |method|
+      define_method method do |*args|
+        query.send method, *args
+        self
+      end
+    end
+  end
+end

data/lib/bol/query.rb

@@ -0,0 +1,79 @@
+module Bol
+  class Query
+    attr_reader :category_id
+    attr_accessor :request
+
+    def initialize(category_id)
+      raise ArgumentError if category_id =~ /[^\d+]/
+      @category_id = category_id
+      @inclusions = []
+    end
+
+    def params
+      { categoryId: @category_id }.tap do |p|
+        p[:nrProducts]         = @limit           if @limit
+        p[:offset]             = @offset          if @offset
+        p[:sortingMethod]      = @order_key       if @order_key
+        p[:sortingAscending]   = @order_direction if @order_direction
+        p[:term]               = @term            if @term
+        p[:includeCategories]  = categories?
+        p[:includeProducts]    = products?
+        p[:includeRefinements] = refinements?
+      end
+    end
+
+    def has_param?(key)
+      params.has_key?(key) and !params[key].nil?
+    end
+
+    def categories?
+      @inclusions.include? :categories
+    end
+
+    def products?
+      @inclusions.include? :products
+    end
+
+    def refinements?
+      @inclusions.include? :refinements
+    end
+
+    def include(kind)
+      @inclusions << kind
+    end
+
+    def search(term = nil)
+      return @term if term.nil?
+      @term = term
+      self
+    end
+
+    def order(str)
+      if str =~ /^(sales_ranking|price|title|publishing_date|customer_rating) (ASC|DESC)/
+        @order_key = $1
+        @order_direction = $2 == 'ASC' ? 'true' : 'false'
+      else
+        raise ArgumentError
+      end
+      self
+    end
+
+    def page(n = nil)
+      limit Bol.configuration[:per_page]
+      offset ((n || 1).to_i - 1) * Bol.configuration[:per_page]
+      self
+    end
+
+    def offset(n = nil)
+      return @offset if n.nil?
+      @offset = n.to_i
+      self
+    end
+
+    def limit(n = nil)
+      return @limit if n.nil?
+      @limit = n.to_i
+      self
+    end
+  end
+end

data/lib/bol/refinement.rb

@@ -0,0 +1,5 @@
+module Bol
+  class Refinement
+    attr_accessor :name, :id, :count
+  end
+end

data/lib/bol/refinement_group.rb

@@ -0,0 +1,5 @@
+module Bol
+  class RefinementGroup
+    attr_accessor :name, :id, :refinements
+  end
+end

data/lib/bol/request.rb

@@ -0,0 +1,90 @@
+require 'forwardable'
+require 'net/https'
+require 'uri'
+
+module Bol
+  NotFound = Class.new(Exception)
+
+  class Request
+    extend Forwardable
+
+    attr_reader :query, :response, :proxy
+
+    DOMAIN = 'openapi.bol.com'
+
+    def_delegators :response, :code, :body
+
+    def self.ignore_params(*args)
+      @params_to_ignore ||= []
+      [*args].each do |arg|
+        @params_to_ignore << arg.to_sym
+      end
+    end
+
+    def self.ignored_param?(name)
+      @params_to_ignore ||= []
+      @params_to_ignore.include?(name.to_sym)
+    end
+
+    def initialize(query)
+      @query = query
+      @query.request = self
+    end
+
+    def proxy
+      @proxy ||= Proxy.new(self, Parsers::Products.new(self))
+    end
+
+    def params
+      @params ||= query.params.reject do |k, v|
+        self.class.ignored_param?(k)
+      end
+    end
+
+    def query_string
+      @query_string ||= params.map { |k, v|
+        "#{URI.escape(k.to_s)}=#{URI.escape(v.to_s)}"
+      }.join('&')
+    end
+
+    def uri
+      @uri ||= begin
+        uri = if params.empty?
+          "https://#{DOMAIN}#{path}"
+        else
+          "https://#{DOMAIN}#{path}?#{query_string}"
+        end
+        URI.parse(uri)
+      end
+    end
+
+    def fetch
+      http             = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl     = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      request          = Net::HTTP::Get.new(uri.request_uri)
+      request.content_type               = 'application/xml'
+      request['Connection']              = 'close'
+      request['X-OpenAPI-Authorization'] = Signature.new(date, path, params).generate
+      request['X-OpenAPI-Date']          = date
+      @response = http.request(request)
+      raise Bol::NotFound if @response.code =~ /^4\d\d$/
+      self
+    end
+
+    def success?
+      response.code == '200'
+    end
+
+  protected
+
+    def date
+      @date ||= Time.now.utc.strftime '%a, %d %B %Y %H:%M:%S GMT'
+    end
+
+    # overridden in subclasses
+    def path
+      '/'
+    end
+  end
+end

data/lib/bol/requests.rb

@@ -0,0 +1,7 @@
+module Bol
+  module Requests
+    autoload :Product,    'bol/requests/product'
+    autoload :Search,     'bol/requests/search'
+    autoload :List,       'bol/requests/list'
+  end
+end

data/lib/bol/requests/list.rb

@@ -0,0 +1,26 @@
+module Bol
+  module Requests
+    class List < Request
+      def initialize(type, *args)
+        @type = type
+        super(*args)
+      end
+
+      def path
+        "/openapi/services/rest/catalog/v3/listresults/#{@type}/#{@query.params[:categoryId]}"
+      end
+
+      def proxy
+        @proxy ||= begin
+          if @query.categories?
+            Proxy.new(self, Parsers::Categories.new(self))
+          elsif @query.refinements?
+            Proxy.new(self, Parsers::Refinements.new(self))
+          elsif @query.products?
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bol/requests/product.rb

@@ -0,0 +1,16 @@
+module Bol
+  module Requests
+    class Product < Request
+      ignore_params :includeCategories, :includeProducts, :includeRefinements
+
+      def initialize(product_id, *args)
+        @product_id = product_id
+        super *args
+      end
+
+      def path
+        "/openapi/services/rest/catalog/v3/products/#{URI.escape(@product_id.to_s)}"
+      end
+    end
+  end
+end

data/lib/bol/requests/search.rb

@@ -0,0 +1,11 @@
+module Bol
+  module Requests
+    class Search < Request
+      ignore_params :includeCategories, :includeProducts, :includeRefinements
+
+      def path
+        "/openapi/services/rest/catalog/v3/searchresults"
+      end
+    end
+  end
+end

data/lib/bol/scope.rb

@@ -0,0 +1,55 @@
+module Bol
+  class Scope
+    attr_reader :ids
+
+    def initialize(ids = nil)
+      @ids = Array(ids)
+      @ids = [0] if @ids.empty?
+    end
+
+    def to_s
+      ids.join('+')
+    end
+
+    def +(other)
+      self.class.new((ids + other.ids).uniq)
+    end
+
+    def -(other)
+      self.class.new(ids - other.ids)
+    end
+
+    def search(terms)
+      q = Query.new(to_s)
+      q.search terms
+      Requests::Search.new(q).proxy
+    end
+
+    def categories
+      q = Query.new(to_s)
+      q.include :categories
+      Requests::List.new('toplist_default', q).proxy
+    end
+
+    def refinements
+      q = Query.new(to_s)
+      q.include :refinements
+      Requests::List.new('toplist_default', q).proxy
+    end
+
+    {
+      top_products: 'toplist_default',
+      top_products_overall: 'toplist_overall',
+      top_products_last_week: 'toplist_last_week',
+      top_products_last_two_months: 'toplist_last_two_months',
+      new_products: 'new',
+      preorder_products: 'preorder'
+    }.each_pair do |method, type|
+      define_method method do
+        q = Query.new(to_s)
+        q.include :products
+        Requests::List.new(type, q).proxy
+      end
+    end
+  end
+end

data/lib/bol/signature.rb

@@ -0,0 +1,44 @@
+require 'base64'
+
+module Bol
+  class Signature
+    attr_reader :date, :path, :params, :key, :secret
+
+    def initialize(date, path, params)
+      @date, @path, @params = date, path, params
+      Bol.configuration.validate
+      @key    = Bol.configuration[:access_key]
+      @secret = Bol.configuration[:secret]
+    end
+
+    def generate
+      key + ':' + encoded_hash
+    end
+
+    private
+
+    def encoded_hash
+      Base64.encode64(hash).sub /\n/, ''
+    end
+
+    def hash
+      OpenSSL::HMAC.digest('sha256', secret, headers)
+    end
+
+    def headers
+      [
+        'GET',
+        '',
+        'application/xml',
+        date,
+        "x-openapi-date:#{date}",
+        path,
+        signature_params
+      ].join("\n")
+    end
+
+    def signature_params
+      params.map { |k, v| "&#{k}=#{v}" }.compact.sort.join("\n")
+    end
+  end
+end