insales_api 0.0.13 → 0.1.0

data/lib/insales_api/helpers/init_api.rb

@@ -0,0 +1,98 @@
+module InsalesApi::Helpers
+  module InitApi
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :insales_app_class
+      self.insales_app_class = InsalesApi::App
+    end
+
+    module ClassMethods
+      # Wraps methods into +init_api+ block. So you can be sure that method
+      # will run for certain account.
+      #
+      #   class Account < ActiveRecord::Base
+      #     include InsalesApi::Helpers
+      #
+      #     def find_products_by_name(name)
+      #       # ...
+      #     end
+      #
+      #     init_api_for :find_products_by_name
+      #   end
+      #
+      #   account1 = Account.find(1)
+      #   account2 = Account.find(2)
+      #
+      #   products1 = account1.find_products_by_name('smth')
+      #   products2 = account2.find_products_by_name('smth_else')
+      #
+      #   # instead of
+      #   # products1 = account1.init_api { find_products_by_name('smth') }
+      #   # products2 = account2.init_api { find_products_by_name('smth_else') }
+      #
+      # Can be used in nessted classes like this:
+      #
+      #   class Order < ActiveRecord::Base
+      #     extend InsalesApi::Helpers::ClassMethods
+      #
+      #     belongs_to :account
+      #
+      #     delegate :init_api, to: :account
+      #
+      #     def insales_order
+      #       InsalesApi::Order.find(insales_id)
+      #     end
+      #
+      #     init_api_for :insales_order
+      #   end
+      #
+      #   insales_order = Order.first.insales_order
+      #
+      def init_api_for(*methods)
+        file, line = caller.first.split(':', 2)
+        methods.each do |method|
+          alias_method_chain method, :init_api do |target, punct|
+            class_eval <<-RUBY, file, line.to_i  - 1
+              def #{target}_with_init_api#{punct}(*args, &block)                # def sell_with_init_api(*args, &block)
+                init_api { #{target}_without_init_api#{punct}(*args, &block) }  #   init_api { sell_without_init_api(*args, &block) }
+              end                                                               # end
+            RUBY
+          end
+        end
+      end
+    end
+
+    # Configures api with credentials taken from +self.insales_domain+ and
+    # +self.insales_password+.
+    #
+    # If block is given, it is evaluated and its result is returned.
+    # After this old configuration is restored.
+    #
+    #   account1 = Account.find(1)
+    #   account2 = Account.find(2)
+    #
+    #   account1.init_api
+    #   # account1 credentials are used
+    #   product1 = InsalesApi::Product.find(1)
+    #   # will search within second account
+    #   product2 = account2.init_api { InsalesApi::Product.find(2) }
+    #   # configuration is restored
+    #   variant1 = InsalesApi::Variants.find(1)
+    #
+    def init_api
+      if block_given?
+        old_config = insales_app_class.dump_config
+        begin
+          init_api
+          yield
+        ensure
+          insales_app_class.restore_config(old_config)
+        end
+      else
+        insales_app_class.configure_api(insales_domain, insales_password)
+        self
+      end
+    end
+  end
+end

data/lib/insales_api/image.rb

@@ -0,0 +1,5 @@
+module InsalesApi
+  class Image < Base
+    self.prefix = "#{prefix}products/:product_id/"
+  end
+end

data/lib/insales_api/order.rb

@@ -1,15 +1,23 @@
+# coding: utf-8
 module InsalesApi
   class Order < Base
+    extend Resource::WithUpdatedSince
+
     def order_lines_attributes
-      @order_lines_attributes = []
-      order_lines.each do |order_line|
-        @order_lines_attributes << order_line.as_json['order_line']
+      @order_lines_attributes = order_lines.map do |order_line|
+        ol = order_line.as_json
+        # при смене версии рельсов (видимо) изменилась сериализация
+        ol = ol['order_line'] if ol['order_line']
+        ol
       end
-      @order_lines_attributes
     end
 
     def to_xml(options = {})
-      super(options.merge({:methods => :order_lines_attributes}))
+      super(options.merge(methods: :order_lines_attributes))
+    end
+
+    def paid?
+      financial_status == 'paid'
     end
   end
 end

data/lib/insales_api/order_line.rb

@@ -1,5 +1,5 @@
 module InsalesApi
   class OrderLine < Base
-    self.prefix = '/admin/orders/:order_id/'
+    self.prefix = "#{prefix}orders/:order_id/"
   end
-end
+end

data/lib/insales_api/product.rb

@@ -1,3 +1,5 @@
 module InsalesApi
-  class Product < Base; end
+  class Product < Base
+    extend Resource::WithUpdatedSince
+  end
 end

data/lib/insales_api/product_field.rb

@@ -0,0 +1,3 @@
+module InsalesApi
+  class ProductField < Base; end
+end

data/lib/insales_api/product_field_value.rb

@@ -0,0 +1,22 @@
+module InsalesApi
+  class ProductFieldValue < Base
+    self.prefix = "#{prefix}products/:product_id/"
+
+    class << self
+      def find_by_field_id(params)
+        field_id = params[:product_field_id]
+        all(params: {product_id: params[:product_id]}).
+          find { |x| x.product_field_id == field_id }
+      end
+
+      def create_or_update(params)
+        if value = find_by_field_id(params)
+          value.update_attribute(:value, params[:value])
+          value
+        else
+          create(params)
+        end
+      end
+    end
+  end
+end

data/lib/insales_api/property.rb

@@ -0,0 +1,3 @@
+module InsalesApi
+  class Property < Base; end
+end

data/lib/insales_api/resource/countable.rb

@@ -0,0 +1,9 @@
+module InsalesApi
+  module Resource
+    module Countable
+      def count(options = {})
+        get(:count, options).to_i
+      end
+    end
+  end
+end

data/lib/insales_api/resource/paginated.rb

@@ -0,0 +1,26 @@
+module InsalesApi
+  PER_PAGE_DEFAULT = 100
+
+  module Resource
+    module Paginated
+      def find_each(*args)
+        find_in_batches(*args) do |batch|
+          batch.each { |record| yield record }
+        end
+      end
+
+      def find_in_batches(options = {})
+        per_page = options[:per_page] || PER_PAGE_DEFAULT
+        params = {per_page: per_page}.merge(options[:params] || {})
+        page = 1
+        loop do
+          items = all(params: params.merge(page: page))
+          return unless items.any?
+          yield items
+          return if items.count < per_page
+          page += 1
+        end
+      end
+    end
+  end
+end

data/lib/insales_api/resource/with_updated_since.rb

@@ -0,0 +1,28 @@
+module InsalesApi
+  module Resource
+    module WithUpdatedSince
+      def find_in_batches(options = {}, &block)
+        return super unless updated_since = options.delete(:updated_since)
+        find_updated_since(updated_since, options, &block)
+      end
+
+      def find_updated_since(updated_since, options = {})
+        per_page = options[:per_page] || PER_PAGE_DEFAULT
+        params    = { per_page: per_page }.merge(options[:params] || {})
+        last_id   = nil
+        loop do
+          items = all(params: params.merge(
+            updated_since:  updated_since,
+            from_id:        last_id,
+          ))
+          return unless items.any?
+          yield items
+          return if items.count < per_page
+          last_item     = items.last
+          last_id       = last_item.id
+          updated_since = last_item.updated_at
+        end
+      end
+    end
+  end
+end

data/lib/insales_api/theme.rb

@@ -1,3 +1,9 @@
 module InsalesApi
-  class Theme < Base; end
+  class Theme < Base
+
+    def assets
+      InsalesApi::Asset.all(params: {theme_id: id})
+    end
+
+  end
 end

data/lib/insales_api/variant.rb

@@ -1,11 +1,23 @@
 module InsalesApi
   class Variant < Base
-    self.prefix = "/admin/products/:product_id/"
-
-    # variants_attrs - массив c модицикациями в формате [{:id => 1, :price => 340, :quantity => 4}, {:id => 2, :price => 350, :quantity => 5}]
-    def self.group_update variants_attrs
-      connection.put("/admin/products/variants_group_update.xml", { :variants => variants_attrs }.to_xml, headers)
+    class << self
+      # Updates all given variants. +variants+ should be array:
+      #
+      #   [
+      #     {
+      #       id: 1,
+      #       price: 340,
+      #       quantity: 4,
+      #     },
+      #     {
+      #       id: 2,
+      #       price: 350,
+      #       quantity: 5,
+      #     },
+      #   ]
+      def group_update(variants)
+        put(:group_update, {}, format.encode(variants, root: :variants))
+      end
     end
-
   end
 end

data/lib/insales_api/version.rb

@@ -1,3 +1,9 @@
 module InsalesApi
-  VERSION = "0.0.13"
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].compact.join('.')
+  end
 end

data/lib/insales_api.rb

@@ -1,40 +1,97 @@
+require 'digest/md5'
+require 'active_support'
 require 'active_support/core_ext'
 require 'active_resource'
 # backport from 4.0
 require 'active_resource/singleton' unless ActiveResource.const_defined?(:Singleton, false)
-require 'digest/md5'
 
 module InsalesApi
   extend ActiveSupport::Autoload
 
+  Deprecator = ActiveSupport::Deprecation.new('1.0', name)
+
   eager_autoload do
-    autoload :Version
-    autoload :App
+    autoload :VERSION
+    autoload :Base
     autoload :Password
+    autoload :App
 
-    autoload :Base
     autoload :Account
+    autoload :ApplicationCharge
+    autoload :ApplicationWidget
+    autoload :Asset
     autoload :Category
     autoload :Client
-    autoload :Collection
+    autoload :ClientGroup
     autoload :Collect
+    autoload :Collection
+    autoload :DeliveryVariant
+    autoload :DiscountCode
+    autoload :Domain
+    autoload :Field
+    autoload :File
+    autoload :Image
+    autoload :JsTag
     autoload :OptionName
     autoload :OptionValue
-    autoload :Product
-    autoload :Variant
-    autoload :Webhook
     autoload :Order
     autoload :OrderLine
-    autoload :ApplicationWidget
-    autoload :Field
-    autoload :DeliveryVariant
-    autoload :PaymentGateway
-    autoload :JsTag
-    autoload :Domain
     autoload :Page
-    autoload :Theme
-    autoload :Asset
+    autoload :PaymentGateway
+    autoload :Product
+    autoload :ProductField
+    autoload :ProductFieldValue
+    autoload :Property
     autoload :RecurringApplicationCharge
-    autoload :File
+    autoload :Theme
+    autoload :Variant
+    autoload :Webhook
   end
+
+  class << self
+    # Calls the supplied block. If the block raises <tt>ActiveResource::ServerError</tt> with 503
+    # code which means Insales API request limit is reached, it will wait for the amount of seconds
+    # specified in 'Retry-After' response header. The called block will receive a parameter with
+    # current attempt number.
+    #
+    # ==== Params:
+    #
+    #   +max_attempts+:: maximum number of attempts. Defaults to +nil+ (unlimited).
+    #   +callback+:: +Proc+ or lambda to execute before waiting. Will receive four arguments: number
+    #                of seconds we are going to wait, number of failed attempts, maximum number of
+    #                attempts and the caught <tt>ActiveResource::ServerError</tt>. Defaults to +nil+
+    #                (no callback).
+    #
+    # ==== Example
+    #
+    #   notify_user = Proc.new do |wait_for, attempt, max_attempts, ex|
+    #     puts "API limit reached. Waiting for #{wait_for} seconds. Attempt #{attempt}/#{max_attempts}"
+    #   end
+    #
+    #   InsalesApi.wait_retry(10, notify_user) do |x|
+    #     puts "Attempt ##{x}."
+    #     products = InsalesApi::Products.all
+    #   end
+    def wait_retry(max_attempts = nil, callback = nil, &block)
+      attempts = 0
+
+      begin
+        attempts += 1
+        yield attempts
+      rescue ActiveResource::ServerError => ex
+        raise ex if '503' != ex.response.code.to_s
+        raise ex if max_attempts && attempts >= max_attempts
+        retry_after = (ex.response['Retry-After'] || 150).to_i
+        callback.call(retry_after, attempts, max_attempts, ex) if callback
+        sleep(retry_after)
+        retry
+      end
+    end
+  end
+
 end
+
+require 'insales_api/helpers/init_api'
+require 'insales_api/helpers/has_insales_object'
+
+ActiveSupport.run_load_hooks(:insales_api, InsalesApi)

data/spec/lib/insales_api/active_resource_proxy_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe InsalesApi::ActiveResourceProxy do
+  let(:proxy) { described_class.new(configurer, object) }
+  let(:configurer) { Object.new.tap { |x| x.stub(:init_api).and_yield } }
+
+  describe '#method_missing' do
+    let(:object) { {} }
+    let(:method_name) { :some_method }
+    subject { proxy.send(method_name) }
+
+    it 'should proxy method to object & pass result through #proxy_for' do
+      result1 = {test: :resut1}
+      result2 = {test: :resut2}
+      object.should_receive(method_name).and_return(result1)
+      proxy.should_receive(:proxy_for).with(result1).and_return(result2)
+      subject.should eq(result2)
+    end
+  end
+
+  describe '::need_proxy?' do
+    subject { described_class.need_proxy?(object) }
+
+    context 'for scalar' do
+      let(:object) { true }
+      it { should be false }
+    end
+
+    context 'for array' do
+      let(:object) { [] }
+      it { should be true }
+    end
+
+    context 'for hash' do
+      let(:object) { {} }
+      it { should be true }
+    end
+
+    context 'for InsalesApi::Base class' do
+      let(:object) { InsalesApi::Account }
+      it { should be true }
+    end
+
+    context 'for InsalesApi::Base object' do
+      let(:object) { InsalesApi::Account.new }
+      it { should be true }
+    end
+
+    context 'for ActiveResource::Collection object' do
+      let(:object) { ActiveResource::Collection.new }
+      it { should be true }
+    end
+
+    context 'for ActiveResource::Base object' do
+      let(:object) { ActiveResource::Base.new }
+      it { should be false }
+    end
+  end
+end

data/spec/lib/insales_api/app_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe InsalesApi::App do
+  let(:domain) { 'my.shop.com' }
+  let(:password) { 'password' }
+  let(:app) { InsalesApi::App.new(domain, password) }
+
+  subject { app }
+
+  describe '#initialize' do
+    its(:domain) { should eq(domain) }
+    its(:password) { should eq(password) }
+    its(:authorized?) { should be false }
+  end
+
+  describe '#configure_api' do
+    it 'configures InsalesApi::Base' do
+      InsalesApi::Base.should_receive(:configure).with(described_class.api_key, domain, password)
+      app.configure_api
+    end
+  end
+
+  describe '#salt' do
+    its(:salt) { should be }
+  end
+
+  describe '#auth_token' do
+    its(:auth_token) { should eq(InsalesApi::Password.create(app.password, app.salt)) }
+  end
+
+  describe 'authorization_url' do
+    subject { app.authorization_url }
+    let(:expected) do
+      URI::Generic.build(
+        scheme:   'http',
+        host:     domain,
+        path:     "/admin/applications/#{app.api_key}/login",
+        query:    {
+          token:  app.salt,
+          login:  app.api_autologin_url,
+        }.to_query,
+      ).to_s
+    end
+    it { should eq(expected) }
+  end
+
+  describe '#authorize' do
+    before { app.auth_token }
+    subject { app.authorize(token) }
+
+    context 'when valid token is given' do
+      let(:token) { app.auth_token }
+      it { should be true }
+    end
+
+    context 'when invalid token is given' do
+      let(:token) { 'bad_token' }
+      it { should be false }
+    end
+  end
+
+  describe '::password_by_token' do
+    let(:token) { 'test' }
+    subject { InsalesApi::App.password_by_token(token) }
+    it { should eq(InsalesApi::Password.create(InsalesApi::App.api_secret, token)) }
+  end
+end

data/spec/lib/insales_api_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe InsalesApi do
+
+  describe '.wait_retry' do
+
+    response_stub = Struct.new(:code, :retry_after) do
+      def [](key)
+        {'Retry-After' => retry_after}[key]
+      end
+    end
+
+    it 'should not run without block' do
+      expect do
+        described_class.wait_retry(20, nil)
+      end.to raise_error
+    end
+
+    it 'should handle succesfull request' do
+      counter = 0
+      described_class.wait_retry do
+        counter += 1
+      end
+
+      expect(counter).to eq(1)
+    end
+
+    it 'should make specified amount of attempts' do
+      counter = 0
+      described_class.wait_retry(3) do
+        counter += 1
+
+        if counter < 3
+          raise ActiveResource::ServerError.new(response_stub.new("503", "0"))
+        end
+      end
+
+      expect(counter).to eq(3)
+    end
+
+    it 'should use callback proc' do
+      callback = Proc.new{}
+      counter = 0
+      callback.should_receive(:call).with(0, 1, 3, instance_of(ActiveResource::ServerError))
+      callback.should_receive(:call).with(0, 2, 3, instance_of(ActiveResource::ServerError))
+
+      described_class.wait_retry(3, callback) do
+        counter += 1
+
+        if counter < 3
+          raise ActiveResource::ServerError.new(response_stub.new("503", "0"))
+        end
+      end
+    end
+
+    it 'should pass attempt number to block' do
+      last_attempt_no = 0
+      described_class.wait_retry(3) do |x|
+        last_attempt_no = x
+
+        if last_attempt_no < 3
+          raise ActiveResource::ServerError.new(response_stub.new("503", "0"))
+        end
+      end
+
+      expect(last_attempt_no).to eq(3)
+    end
+
+    it 'should raise if no attempts left' do
+      expect do
+        described_class.wait_retry(3) do |x|
+          raise ActiveResource::ServerError.new(response_stub.new("503", "0"))
+        end
+      end.to raise_error(ActiveResource::ServerError)
+    end
+
+    it 'should raise on user errors' do
+      attempts = 0
+      expect do
+        described_class.wait_retry(3) do |x|
+          attempts = x
+          raise 'Some other error'
+        end
+      end.to raise_error(StandardError)
+      expect(attempts).to eq(1)
+    end
+
+    it 'should raise on other server errors' do
+      attempts = 0
+      expect do
+        described_class.wait_retry(3) do |x|
+          attempts = x
+          raise ActiveResource::ServerError.new(response_stub.new("502", "0"))
+        end
+      end.to raise_error(ActiveResource::ServerError)
+      expect(attempts).to eq(1)
+    end
+
+    it 'should run until success' do |x|
+      success = false
+      described_class.wait_retry do |x|
+        raise ActiveResource::ServerError.new(response_stub.new("503", "0")) if x < 10
+        success = true
+      end
+
+      expect(success).to be_true
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -2,10 +2,9 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'insales_api'
 
-InsalesApi::App.api_key            = 'test'
-InsalesApi::App.api_secret         = 'test'
-InsalesApi::App.api_host           = 'myshop.insales.ru'
-InsalesApi::App.api_autologin_path = 'session/autologin'
+InsalesApi::App.api_key           = 'test'
+InsalesApi::App.api_secret        = 'test'
+InsalesApi::App.api_autologin_url = 'https://host.com/session/autologin'
 
 RSpec.configure do |config|
   # == Mock Framework