insales_api 0.0.13 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21c7b7e853b3998b60bd9e067abc75be2837608d
-  data.tar.gz: 1e3cdaf7a448b016227d6fc8f5b2f4a82ae48572
+  metadata.gz: 0874e0c3d9d031bd7c44623652e9f8d0118bbca1
+  data.tar.gz: d8f445c2fd2f722d03368b0cef92430f4bb338b4
 SHA512:
-  metadata.gz: 7f62cd468de7f1da9773068404b6b715a420d68eb106b2b3a3f15a9cd18da7cc3bc6c47d3aa4bd45cd90c751c2243687958b076b0a32fcc5b99a5c25fc4c56de
-  data.tar.gz: ac1324ae0d02fb0995752d05987f764e05cfda89afabc1c17e7ebe5ea60e6ad0f2fef0aa3338267cb2b4a3bfcb350deb537f264427091925b6347ee3eb94a9c8
+  metadata.gz: 106dfba38c2704be7e63243f6493d441d440a200dc9f6a39454e21ea40c765cf16d5859f8103f5305786445ced8a42014603dbd1a43c56dc67adf8bea23bdc82
+  data.tar.gz: de95a094d63c5e09583943e56296f3d66f2a91e37246538afb499e7aae6252a832044acb8eaf74fa16a9c97dd163752bf5862c050af4dad5bc37ec03e1b9d5ed

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.1.0
+notifications:
+  email: false

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## 0.1.0
+
+* Helpers
+* ProductFieldValue
+* Controller auth mixins
+* Account inherits AR::Singleton (it breaks ::current & #update methods)
+* Added wait_retry method
+* Added Property resource
+* Added ProductField resource
+* Added ClientGroup resource
+
+## 0.0.14
+
+* Added Image resource
+* Fixed Variant.group_update
+* Added DiscountCode resource
+* Added Product.count method
+* Added Order.paid? method
+* Added ApplicationCharge resource
+
 ## 0.0.13
 
 * ActiveResource::Singleton backport.

data/Gemfile

@@ -1,3 +1,3 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 
 gemspec

data/README.md

@@ -0,0 +1,57 @@
+# InsalesApi gem
+
+[![Build Status](https://secure.travis-ci.org/insales/insales_api.png?branch=master)](http://travis-ci.org/insales/insales_api)
+
+Insales api client based on [ActiveResource](https://github.com/rails/activeresource).
+
+Rails application example is [here](https://github.com/insales/insales_app).
+
+## Install
+
+Add to Gemfile:
+
+```ruby
+gem 'insales_api'
+```
+
+## Initialize
+
+```ruby
+class MyApp < InsalesApi::App
+  self.api_key = 'api_key'
+end
+
+MyApp.configure_api('domain', 'password')
+```
+
+## Use
+
+```ruby
+order = InsalesApi::Order.find 123
+
+# singleton resources
+account = InsalesApi::Account.find
+```
+
+### Handling Insales API request limit
+
+There is a 500 requests per 5 minutes limit for Insales API. To handle this limitation gracefully, use `InsalesApi.wait_retry` method:
+```ruby
+# prepare a handler for request limit case
+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
+
+# perform 10 attempts to get products
+InsalesApi.wait_retry(10, notify_user) do |x|
+  puts "Attempt ##{x}."
+  products = InsalesApi::Products.all
+end
+```
+
+If you don't need to cap the attempts number or you don't want to do any special processing, simply drop the arguments:
+```ruby
+InsalesApi.wait_retry do
+  products = InsalesApi::Products.all # will try to get products until the limit resets
+end
+```

data/Rakefile

@@ -1 +1,8 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task default: :spec

data/insales_api.gemspec

@@ -1,23 +1,23 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "insales_api/version"
+$:.push File.expand_path('../lib', __FILE__)
+require 'insales_api/version'
 
 Gem::Specification.new do |s|
-  s.name        = "insales_api"
-  s.version     = InsalesApi::VERSION
-  s.authors     = "InSales"
-  s.email       = "dg@insales.ru"
-  s.homepage    = "http://wiki.insales.ru/wiki/%D0%9A%D0%B0%D0%BA_%D0%B8%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%D1%81%D1%8F_%D1%81_InSales"
+  s.name        = 'insales_api'
+  s.version     = InsalesApi::VERSION::STRING
+  s.authors     = 'InSales'
+  s.email       = 'dg@insales.ru'
+  s.homepage    = 'https://github.com/insales/insales_api'
   s.summary     = %q{Gem for accessing the InSales REST web services}
   s.description = %q{Gem for accessing the InSales REST web services}
 
-  s.rubyforge_project = "insales_api"
+  s.rubyforge_project = 'insales_api'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
 
-  s.add_dependency("activesupport", [">= 3.0.0"])
-  s.add_dependency("activeresource", [">= 3.0.0"])
-  s.add_development_dependency "rspec"
+  s.add_dependency('activesupport', ['>= 3.0.0'])
+  s.add_dependency('activeresource', ['>= 3.0.0'])
+  s.add_development_dependency 'rspec', '~> 2.13.0'
+  s.add_development_dependency 'rake', '~> 10.3'
 end

data/lib/insales/controller/autologin.rb

@@ -0,0 +1,45 @@
+module Insales::Controller
+  module Autologin
+    protected
+      def insales_authenticate!
+        params[:domain] ||= params[:shop]
+        insales_logout if params[:domain].present? && params[:domain] != session[:domain]
+        return if insales_authenticate_from_session
+        store_location
+        account = find_account_by_request
+        return insales_autologin_start(account) if account
+        redirect_to insales_login_path
+      end
+
+      def insales_authenticate_from_session
+        data = session[:insales_session]
+        return unless data && data[:account_id] && data[:insales_id]
+        @account = account_class.where(account_id: data[:account_id]).
+          find_by_insales_id(data[:insales_id])
+      end
+
+      def insales_autologin_start(account)
+        app = insales_app_class.new(account.insales_domain, account.insales_password)
+        auth_url = app.authorization_url
+        session[:insales_token] = app.auth_token
+        session[:insales_token_data] = {
+          domain:       account.insales_domain,
+          account_id:   account.id,
+          insales_id:   account.insales_id,
+        }
+        redirect_to auth_url
+      end
+
+      def insales_autologin_finish(token = params[:token])
+        if token && session[:insales_token] == token && session[:insales_token_data].is_a?(Hash)
+          session[:insales_session] = session[:insales_token_data]
+        end
+        session[:insales_token] = session[:insales_token_data] = nil
+        session[:account_id].present?
+      end
+
+      def insales_logout
+        session.delete(:insales_session)
+      end
+  end
+end

data/lib/insales/controller/base_helpers.rb

@@ -0,0 +1,52 @@
+module Insales::Controller
+  module BaseHelpers
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :insales_config
+      self.insales_config = {
+        account_class:      '::Account',
+        insales_app_class:  '::InsalesApi::App',
+        login_path:         'login_path',
+        success_login_path: 'account_path',
+      }
+
+      def account_class
+        @account_class ||= insales_config[:account_class].constantize
+      end
+
+      def insales_app_class
+        @insales_app_class ||= insales_config[:insales_app_class].constantize
+      end
+
+      def insales_login_path
+        send(insales_config[:login_path])
+      end
+
+      def insales_success_login_path
+        send(insales_config[:success_login_path])
+      end
+    end
+
+    protected
+      delegate :insales_app_class, :account_class,
+        :insales_login_path, :insales_success_login_path,
+        to: :class
+
+      def store_location(path = request.url)
+        session[:return_to] = path
+      end
+
+      def stored_location
+        session.delete(:return_to)
+      end
+
+      def find_account_by_request
+        if params[:insales_id]
+          account_class.find_by_insales_id(params[:insales_id])
+        elsif params[:domain]
+          account_class.find_by_insales_domain(params[:domain])
+        end
+      end
+  end
+end

data/lib/insales/controller/installer_actions.rb

@@ -0,0 +1,19 @@
+module Insales::Controller
+  module InstallerActions
+    def install
+      if insales_app_class.install(params[:shop], params[:token], params[:insales_id])
+        head :ok
+      else
+        raise 'Instalation failed'
+      end
+    end
+
+    def uninstall
+      if insales_app_class.uninstall(params[:shop], params[:token])
+        head :ok
+      else
+        raise 'Uninstallation failed'
+      end
+    end
+  end
+end

data/lib/insales/controller/session_actions.rb

@@ -0,0 +1,39 @@
+module Insales::Controller
+  module SessionActions
+    extend ActiveSupport::Concern
+
+    included do
+      skip_before_filter :insales_authenticate!, except: [:destroy]
+    end
+
+    def new
+      # render
+    end
+
+    def create
+      account = find_account_by_request
+      return render_not_found unless account
+      store_location(insales_success_login_path)
+      insales_autologin_start(account)
+    end
+
+    def autologin
+      if insales_autologin_finish
+        redirect_to stored_location || insales_success_login_path
+      else
+        redirect_to action: :new
+      end
+    end
+
+    def destroy
+      insales_logout
+      redirect_to action: :new
+    end
+
+    protected
+      def render_not_found
+        flash.now[:error] = t(:'.account_not_found').html_safe
+        render action: :new
+      end
+  end
+end

data/lib/insales/controller.rb

@@ -0,0 +1,10 @@
+module Insales
+  module Controller
+    extend ActiveSupport::Autoload
+
+    autoload :BaseHelpers
+    autoload :Autologin
+    autoload :SessionActions
+    autoload :InstallerActions
+  end
+end

data/lib/insales.rb

@@ -0,0 +1,7 @@
+require 'insales_api'
+
+module Insales
+  extend ActiveSupport::Autoload
+
+  autoload :Controller
+end

data/lib/insales_api/account.rb

@@ -1,13 +1,5 @@
 module InsalesApi
   class Account < Base
-    def self.current
-      find(:one, :from => '/admin/account.xml')
-    end
-
-    def update
-      connection.put('/admin/account.xml', encode, self.class.headers).tap do |response|
-        load_attributes_from_response(response)
-      end
-    end
+    include ActiveResource::Singleton
   end
 end

data/lib/insales_api/active_resource_proxy.rb

@@ -0,0 +1,31 @@
+module InsalesApi
+  class ActiveResourceProxy
+    class << self
+      def need_proxy?(value)
+        return true if value.is_a?(Hash) || value.is_a?(Array)
+        klass = value.is_a?(Class) ? value : value.class
+        return true if klass < Base || klass <= ActiveResource::Collection
+        false
+      end
+    end
+
+    def initialize(configurer, subject)
+      @configurer = configurer
+      @subject    = subject
+    end
+
+    def respond_to_missing?(method_name)
+      @subject.respond_to?(method_name) || super
+    end
+
+    def method_missing(method_id, *args, &block)
+      @configurer.init_api { proxy_for @subject.send(method_id, *args, &block) }
+    end
+
+    private
+      def proxy_for(value)
+        return value unless self.class.need_proxy?(value)
+        self.class.new(@configurer, value)
+      end
+  end
+end

data/lib/insales_api/app.rb

@@ -1,35 +1,72 @@
 module InsalesApi
   class App
-    class_attribute :api_key, :api_host, :api_secret, :api_autologin_path
-    attr_reader :authorized, :auth_token, :shop, :password
+    class_attribute :api_key, :api_secret, :api_autologin_url, :api_host, :api_autologin_path,
+      :base_resource_class
+    attr_reader :authorized, :domain, :password
+    self.base_resource_class = Base
 
-    def initialize(shop, password)
+    class << self
+      def configure_api(domain, password)
+        base_resource_class.configure(api_key, domain, password)
+      end
+
+      delegate :dump_config, :restore_config, to: :base_resource_class
+
+      def prepare_domain(domain)
+        domain.to_s.strip.downcase
+      end
+
+      alias_method :prepare_shop, :prepare_domain
+      deprecate prepare_shop: :prepare_domain,
+        api_host: :api_autologin_url,
+        api_autologin_path: :api_autologin_url,
+        deprecator: Deprecator
+
+      def install(domain, token, insales_id)
+        true
+      end
+
+      def uninstall(domain, password)
+        true
+      end
+
+      def password_by_token(token)
+        InsalesApi::Password.create(api_secret, token)
+      end
+    end
+
+    def initialize(domain, password)
       @authorized = false
-      @shop       = self.class.prepare_shop shop
+      @domain     = self.class.prepare_domain(domain)
       @password   = password
     end
 
     def authorization_url
-      store_auth_token
-      "http://#{shop}/admin/applications/#{self.class.api_key}/login?" \
-        "token=#{salt}&login=http://#{self.class.api_host}/#{self.class.api_autologin_path}"
+      host, port = domain, nil
+      match = /(.+):(\d+)/.match host
+      host, port = match[1..2] if match
+      URI::Generic.build(
+        scheme:   'http',
+        host:     host,
+        port:     port && port.to_i,
+        path:     "/admin/applications/#{api_key}/login",
+        query:    {
+          token:  salt,
+          login:  api_autologin_url || "http://#{api_host}/#{api_autologin_path}",
+        }.to_query,
+      ).to_s
     end
 
-    def store_auth_token
+    def auth_token
       @auth_token ||= InsalesApi::Password.create(password, salt)
     end
 
     def salt
-      @salt ||= Digest::MD5.hexdigest("Twulvyeik#{$$}#{Time.now.to_i}thithAwn")
+      @salt ||= SecureRandom.hex
     end
 
-    def authorize token
-      @authorized = false
-      if self.auth_token and self.auth_token == token
-        @authorized = true
-      end
-
-      @authorized
+    def authorize(token)
+      @authorized = auth_token == token
     end
 
     def authorized?
@@ -37,29 +74,11 @@ module InsalesApi
     end
 
     def configure_api
-      self.class.configure_api shop, password
+      self.class.configure_api(domain, password)
     end
 
-    class << self
-      def configure_api shop, password
-        InsalesApi::Base.configure api_key, shop, password
-      end
-
-      def prepare_shop shop
-        shop.to_s.strip.downcase
-      end
-
-      def install shop, token, insales_id
-        true
-      end
-
-      def uninstall shop, password
-        true
-      end
-
-      def password_by_token token
-        InsalesApi::Password.create(api_secret, token)
-      end
-    end
+    alias_method :store_auth_token, :auth_token
+    alias_method :shop, :domain
+    deprecate store_auth_token: :auth_token, shop: :domain, deprecator: Deprecator
   end
 end

data/lib/insales_api/application_charge.rb

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

data/lib/insales_api/asset.rb

@@ -1,3 +1,5 @@
 module InsalesApi
-  class Asset < Base; end
+  class Asset < Base
+    self.prefix = "#{prefix}themes/:theme_id/"
+  end
 end

data/lib/insales_api/base.rb

@@ -1,12 +1,48 @@
+require 'insales_api/resource/countable'
+require 'insales_api/resource/paginated'
+require 'insales_api/resource/with_updated_since'
+require 'insales_api/active_resource_proxy'
+
 module InsalesApi
   class Base < ActiveResource::Base
+    extend Resource::Countable
+    extend Resource::Paginated
+
+    self.include_root_in_json = false
+    self.headers['User-Agent'] = %W(
+      InsalesApi/#{InsalesApi::VERSION}
+      ActiveResource/#{ActiveResource::VERSION::STRING}
+      Ruby/#{RUBY_VERSION}
+    ).join(' ')
     self.format = :xml
+    self.prefix = '/admin/'
+
+    class << self
+      def configure(api_key, domain, password)
+        self.user     = api_key
+        self.site     = "http://#{domain}"
+        self.password = password
+        self
+      end
+
+      def dump_config
+        {
+          user:     self.user,
+          site:     self.site,
+          password: self.password,
+        }
+      end
+
+      def restore_config(options)
+        self.user     = options[:user]
+        self.site     = options[:site]
+        self.password = options[:password]
+        true
+      end
 
-    def self.configure(api_key, shop, password)
-      self.user     = api_key
-      self.site     = "http://#{shop}/admin/"
-      self.password = password
-      nil
+      def for_account(account)
+        ActiveResourceProxy.new(account, self)
+      end
     end
   end
 end

data/lib/insales_api/category.rb

@@ -1,7 +1,13 @@
 module InsalesApi
   class Category < Base
-    def self.set_products_category new_category_id, product_ids
-      connection.put("/admin/categories/set_products_category.xml", {:id => new_category_id, :product_ids => Array(product_ids)}.to_xml(:root => :new_category), headers)
+    class << self
+      def set_products_category(new_category_id, product_ids)
+        data = {
+          id:           new_category_id,
+          product_ids:  Array(product_ids),
+        }
+        put(:set_products_category, {}, format.encode(data, root: :new_category))
+      end
     end
   end
 end

data/lib/insales_api/client.rb

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

data/lib/insales_api/client_group.rb

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

data/lib/insales_api/collect.rb

@@ -1,7 +1,13 @@
 module InsalesApi
   class Collect < Base
-    def self.group_create product_ids, collection_ids
-      connection.post("/admin/collects/group_create.xml", {:collection_ids => Array(collection_ids), :product_ids => Array(product_ids)}.to_xml(:root => :group_create), headers)
+    class << self
+      def group_create(product_ids, collection_ids)
+        data = {
+          collection_ids: Array(collection_ids),
+          product_ids:    Array(product_ids),
+        }
+        post(:group_create, {}, format.encode(data, root: :group_create))
+      end
     end
   end
 end

data/lib/insales_api/discount_code.rb

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

data/lib/insales_api/helpers/has_insales_object.rb

@@ -0,0 +1,34 @@
+module InsalesApi::Helpers
+  module HasInsalesObject
+    def has_insales_object(type, options = {})
+      i_method_name = "insales_#{type}"
+      class_method_name = "insales_#{type}_class"
+      object_class = options[:class] || InsalesApi.const_get(type.to_s.camelcase)
+      helpers = Module.new do
+        extend ActiveSupport::Concern
+
+        module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          included do                                                           # included do
+            class_attribute :#{class_method_name}                               #   class_attribute :insales_order_class
+            self.#{class_method_name} = #{object_class}                         #   self.insales_order_class = InsalesApi::Order
+          end                                                                   # end
+                                                                                #
+          def #{i_method_name}(force = false)                                   # def insales_order(force = false)
+            return @#{i_method_name} if @#{i_method_name} && !force             #   return @insales_order if @insales_order && !force
+            @#{i_method_name} = init_api do                                     #   @insales_order = init_api do
+              #{class_method_name}.find(insales_id)                             #     insales_order_class.find(insales_id)
+            end                                                                 #   end
+          end                                                                   # end
+                                                                                #
+          attr_writer :#{i_method_name}                                         # attr_writer :insales_order
+                                                                                #
+          def reload(*)                                                         # def reload(*)
+            @#{i_method_name} = nil                                             #   @insales_order = nil
+            super                                                               #   super
+          end                                                                   # end
+        RUBY
+      end
+      include helpers
+    end
+  end
+end