cdek_client 0.0.1

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/cdek_client.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cdek_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cdek_client'
+  spec.version       = CdekClient::VERSION
+  spec.authors       = ['Babur Usenakunov']
+  spec.email         = ['bob.usenakunov@gmail.com']
+  spec.summary       = %q{Client for CDEK logistics service API}
+  spec.description   = %q{Client for CDEK logistics service API}
+  spec.homepage      = 'https://github.com/bob-frost/cdek_client'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+  
+  spec.add_dependency 'httparty', '~> 0.11'  
+  spec.add_dependency 'nokogiri', '~> 1.5'
+
+  spec.add_development_dependency 'bundler', '~> 1.0'
+end

data/lib/cdek_client.rb

@@ -0,0 +1,153 @@
+require 'cdek_client/client'
+
+module CdekClient
+
+  extend self
+
+  HOSTS = {
+    primary: {
+      host: 'gw.edostavka.ru',
+      port: 11443
+    }.freeze,
+    secondary: {
+      host: 'lk.cdek.ru',
+      port: 11443
+    }.freeze,
+    calculator_primary: {
+      host: 'api.edostavka.ru',
+      port: 80
+    }.freeze,
+    calculator_secondary: {
+      host: 'lk.cdek.ru',
+      port: 8080
+    }.freeze
+  }.freeze
+
+  PATHS = {
+    pickup_points:  'pvzlist.php',
+    order_statuses: 'status_report_h.php',
+    order_infos:    'info_report.php',
+    new_orders:     'new_orders.php',
+    new_schedule:   'new_schedule.php',
+    call_courier:   'call_courier.php',
+    delete_orders:  'delete_orders.php',
+    orders_print:   'orders_print.php',
+    calculate:      'calculator/calculate_price_by_json.php'
+  }.freeze
+
+  RESPONSE_NORMALIZATION_RULES = {
+    pickup_points: {
+      CityCode: :to_i,
+      coordX: :to_f,
+      coordY: :to_f,
+      WeightLimit: {
+        WeightMin: :to_f,
+        WeightMax: :to_f
+      }.freeze
+    }.freeze,
+    
+    order_statuses: {
+      DeliveryDate: :to_time,
+      ReturnDispatchNumber: :to_i,
+      Status: {
+        Date: :to_time,
+        Code: :to_i,
+        CityCode: :to_i,
+        State: {
+          Date: :to_time,
+          Code: :to_i,
+          CityCode: :to_i
+        }.freeze
+      }.freeze,
+      Reason: {
+        Date: :to_time,
+        Code: :to_i
+      }.freeze,
+      DelayReason: {
+        Date: :to_time,
+        Code: :to_i,
+        State: {
+          Date: :to_time,
+          Code: :to_i,
+          CityCode: :to_i
+        }.freeze
+      }.freeze,
+      Package: {
+        Item: {
+          DelivAmount: :to_i
+        }.freeze
+      }.freeze,
+      Attempt: {
+        ScheduleCode: :to_i
+      }.freeze,
+      Call: {
+        CallGood: {
+          Good: {
+            Date: :to_date,
+            DateDeliv: :to_date
+          }.freeze
+        }.freeze,
+        CallFail: {
+          Fail: {
+            Date: :to_date,
+            ReasonCode: :to_i
+          }.freeze
+        }.freeze,
+        CallDelay: {
+          Delay: {
+            Date: :to_date,
+            DateNext: :to_date
+          }.freeze
+        }.freeze
+      }.freeze
+    }.freeze,
+
+    order_infos: {
+      Date: :to_date,
+      TariffTypeCode: :to_i,
+      Weight: :to_f,
+      DeliverySum: :to_f,
+      DateLastChange: :to_time,
+      CashOnDeliv: :to_f,
+      CachOnDelivFac: :to_f,
+      SendCity: {
+        Code: :to_i
+      }.freeze,
+      RecCity: {
+        Code: :to_i
+      }.freeze,
+      AddedService: {
+        ServiceCode: :to_i,
+        Sum: :to_f
+      }.freeze
+    }.freeze,
+
+    calculate: {
+      price: :to_f,
+      deliveryPeriodMin: :to_i,
+      deliveryPeriodMax: :to_i,
+      deliveryDateMin: :to_date,
+      deliveryDateMax: :to_date,
+      tariffId: :to_i,
+      cashOnDelivery: :to_f,
+      priceByCurrency: :to_f
+    }.freeze
+
+  }.freeze
+
+  CALCULATOR_API_VERSION = '1.0'
+
+  TIME_FORMAT = '%Y-%m-%dT%H:%M:%S'
+
+  DATE_FORMAT = '%Y-%m-%d'
+  
+  def generate_secure(formatted_date, password)
+    Digest::MD5.hexdigest("#{formatted_date}&#{password}")
+  end
+
+  def format_date(date_or_time)
+    format = date_or_time.is_a?(Time) || date_or_time.is_a?(DateTime) ? TIME_FORMAT : DATE_FORMAT
+    date_or_time.strftime(format)
+  end
+
+end

data/lib/cdek_client/abstract_client.rb

@@ -0,0 +1,120 @@
+require 'httparty'
+require 'nokogiri'
+
+require 'cdek_client'
+require 'cdek_client/errors'
+require 'cdek_client/result'
+require 'cdek_client/util'
+
+module CdekClient
+  class AbstractClient
+
+    protected
+
+    def url_for(host_key, path_key)
+      URI.join("http://#{CdekClient::HOSTS[host_key][:host]}:#{CdekClient::HOSTS[host_key][:port]}", CdekClient::PATHS[path_key]).to_s
+    end
+
+    def response_normalization_rules_for(key)
+      CdekClient::RESPONSE_NORMALIZATION_RULES[key]
+    end
+
+    def normalize_request_data(data)
+      case data
+      when Hash
+        result = {}
+        data.each do |key, value|
+          result[key.to_sym] = normalize_request_data(value)
+        end
+        return result
+      when Array
+        result = []
+        data.each do |value|
+          result.push normalize_request_data(value)
+        end
+        return result
+      when Date, Time
+        return CdekClient.format_date data
+      else
+        return data
+      end
+    end
+
+    def normalize_response_data(data, rules, keypath = [])
+      if data.nil? || (data.is_a?(String) && data.strip.empty?)
+        return nil
+      end
+
+      case data
+      when Hash
+        result = {}
+        data.each do |key, value|
+          key = key.to_sym
+          result[key] = normalize_response_data(value, rules, keypath + [key])
+        end
+        return result
+      when Array
+        result = []
+        data.each do |value|
+          result.push normalize_response_data(value, rules, keypath)
+        end
+        return result
+      else
+        rule = rules.nil? ? nil : Util.hash_value_at_keypath(rules, keypath)
+        case rule
+        when :to_i, :to_f
+          return data.send rule
+        when :to_date
+          begin
+            return Date.parse data
+          rescue ArgumentError => e
+            puts "Couldn't parse date '#{data}' at #{keypath.join '.'} with #{e.class.name}: #{e.message}!"
+            return data
+          end
+        when :to_time
+          begin
+            return Time.parse data
+          rescue ArgumentError => e
+            puts "Couldn't parse time '#{data}' at #{keypath.join '.'} with #{e.class.name}: #{e.message}!"
+            return data
+          end
+        else
+          return data
+        end
+      end
+    end
+
+    def raw_request(url, retry_url, method, request_params, params)
+      if !Util.blank?(params)
+        if method == :post
+          request_params = request_params.merge body: params
+        else
+          request_params = request_params.merge query: params
+        end
+      end
+
+      begin
+        response = HTTParty.send method, url, request_params
+        if response.code == 200
+          return CdekClient::Result.new response, response.body
+        else
+          raise CdekClient::ResponseError.new response.code, response.message
+        end
+      rescue CdekClient::ResponseError, HTTParty::ResponseError => e
+        if Util.blank? retry_url
+          error = e.is_a?(CdekClient::ResponseError) ? e : (CdekClient::ResponseError.new e.response.code, e.response.message)
+          return CdekClient::Result.new response, response.body, [error]
+        else
+          return raw_request url, nil, method, request_params, nil
+        end
+      rescue Timeout::Error, Errno::ETIMEDOUT => e
+        if Util.blank? retry_url
+          return CdekClient::Result.new response, response.body, [e]
+        else
+          return raw_request url, nil, method, request_params, nil
+        end
+      end
+    end
+
+  end
+end

data/lib/cdek_client/calculator_client.rb

@@ -0,0 +1,68 @@
+require 'httparty'
+require 'json'
+
+require 'cdek_client/abstract_client'
+require 'cdek_client/calculator_errors'
+require 'cdek_client/util'
+
+module CdekClient
+  
+  class CalculatorClient < AbstractClient
+
+    def initialize(account = nil, password = nil)
+      @account = account
+      @password = password
+    end
+
+    def calculate(params)
+      params = normalize_request_data params
+      formatted_date_execute = if params[:dateExecute].is_a?(Date) || params[:dateExecute].is_a?(Time)
+        CdekClient.format_date params[:dateExecute]
+      elsif !Util.blank? params[:dateExecute]
+        params[:dateExecute]
+      else
+        CdekClient.format_date Date.today
+      end
+      params.merge!(
+        version: CdekClient::CALCULATOR_API_VERSION,
+        dateExecute: formatted_date_execute
+      )
+      if !@account.nil? && !@password.nil?
+        params.merge!({
+          authLogin: @account,
+          secure: CdekClient.generate_secure(formatted_date_execute, @password)
+        })
+      end
+      result = request url_for(:calculator_primary, :calculate), url_for(:calculator_secondary, :calculate), :post, params
+      if result.errors.any?
+        result.set_data({})
+      elsif result.data.has_key?(:error)
+        Util.array_wrap(result.data[:error]).each do |error_data|
+          error = Calculator.get_api_error error_data[:code], error_data[:text]
+          result.add_error error
+        end
+        result.set_data({})
+      else
+        normalized_data = normalize_response_data result.data[:result], response_normalization_rules_for(:calculate)
+        result.set_data normalized_data
+      end
+      return result
+    end
+
+    private
+
+    def request(url, retry_url, method, params = {})
+      params = params.to_json
+      request_params = { 
+        headers: { 'Content-Type' => 'application/json' }
+      }
+      result = raw_request url, retry_url, method, {}, params
+      if !Util.blank? result.data
+        data = Util.deep_symbolize_keys JSON.parse(result.data)
+        result.set_data data
+      end
+      result
+    end
+
+  end
+end

data/lib/cdek_client/calculator_errors.rb

@@ -0,0 +1,73 @@
+require 'cdek_client/errors'
+
+module CdekClient
+  module Calculator
+
+    class Error < CdekClient::Error; end
+
+    class APIError < Error; end
+
+    class UnkownAPIError < APIError; end
+
+    class ServerError < APIError; end
+
+    class ApiVersionError < APIError; end
+
+    class AuthError < APIError; end
+
+    class DeliveryImpossibleError < APIError; end
+
+    class PlaceParamsError < APIError; end
+
+    class PlaceEmptyError < APIError; end
+
+    class TariffEmptyError < APIError; end
+
+    class SenderCityEmptyError < APIError; end
+
+    class ReceiverCityEmptyError < APIError; end
+
+    class DateEmptyError < APIError; end
+
+    class DeliveryTypeError < APIError; end
+
+    class FormatError < APIError; end
+
+    class DecodeError < APIError; end
+
+    class SenderPostcodeNotFoundError < APIError; end
+
+    class SenderPostcodeAmbigiousError < APIError; end
+
+    class ReceiverPostcodeNotFoundError < APIError; end
+
+    class ReceiverPostcodeAmbigiousError < APIError; end
+
+    def self.get_api_error(code, message)
+      code = code.to_i if !code.is_a?(Integer) && code.to_s =~ /^\d+$/ 
+      klass = API_ERROR_MAPPINGS[code] || UnkownAPIError
+      klass.new code, message
+    end
+
+    API_ERROR_MAPPINGS = {
+      0 => ServerError,
+      1 => ApiVersionError,
+      2 => AuthError,
+      3 => DeliveryImpossibleError,
+      4 => PlaceParamsError,
+      5 => PlaceEmptyError,
+      6 => TariffEmptyError,
+      7 => SenderCityEmptyError,
+      8 => ReceiverCityEmptyError,
+      9 => DateEmptyError,
+      10 => DeliveryTypeError,
+      11 => FormatError,
+      12 => DecodeError,
+      13 => SenderPostcodeNotFoundError,
+      14 => SenderPostcodeAmbigiousError,
+      15 => ReceiverPostcodeNotFoundError,
+      16 => ReceiverPostcodeAmbigiousError
+    }
+
+  end
+end

data/lib/cdek_client/client.rb

@@ -0,0 +1,256 @@
+require 'httparty'
+require 'nokogiri'
+
+require 'cdek_client/abstract_client'
+require 'cdek_client/calculator_client'
+require 'cdek_client/util'
+
+module CdekClient
+  class Client < AbstractClient
+
+    def initialize(account = nil, password = nil)
+      @account = account
+      @password = password
+    end
+
+    def pickup_points(params = {})
+      params = normalize_request_data params
+      result = request url_for(:primary, :pickup_points), url_for(:secondary, :pickup_points), :get, params
+      if result.errors.any?
+        result.set_data []
+        return result
+      end
+      if result.data[:PvzList].has_key? :ErrorCode
+        error = CdekClient.get_api_error result.data[:PvzList][:ErrorCode], result.data[:PvzList][:Msg]
+        result.add_error error
+        result.set_data []
+      else
+        normalized_data = Util.array_wrap result.data[:PvzList][:Pvz]
+        normalized_data = normalize_response_data normalized_data, response_normalization_rules_for(:pickup_points)
+        result.set_data normalized_data
+      end
+      result
+    end
+
+    def order_statuses(params = {})
+      params = normalize_request_data params
+      params = { StatusReport: params }
+      result = authorized_request url_for(:primary, :order_statuses), url_for(:secondary, :order_statuses), params
+      if result.errors.any?
+        result.set_data []
+        return result
+      end
+      if result.data[:StatusReport].has_key? :ErrorCode
+        error = CdekClient.get_api_error result.data[:StatusReport][:ErrorCode], result.data[:StatusReport][:Msg]
+        result.add_error error
+        result.set_data []
+      else
+        normalized_data = Util.array_wrap result.data[:StatusReport][:Order]
+        normalized_data = normalize_response_data normalized_data, response_normalization_rules_for(:order_statuses)
+        result.set_data normalized_data
+      end
+      result
+    end
+
+    def order_infos(params)
+      params = normalize_request_data params
+      params = { InfoRequest: params }
+      result = authorized_request url_for(:primary, :order_infos), url_for(:secondary, :order_infos), params
+      if result.errors.any?
+        result.set_data []
+        return result
+      end
+      if result.data.has_key? :response
+        result.data[:response].values.each do |error_data|
+          error = CdekClient.get_api_error error_data[:ErrorCode], error_data[:Msg]
+          result.add_error error
+        end
+        result.set_data []
+      elsif result.data.has_key?(:InfoReport) && result.data[:InfoReport].is_a?(Hash)
+        normalized_data = Util.array_wrap result.data[:InfoReport][:Order]
+        normalized_data = normalize_response_data normalized_data, response_normalization_rules_for(:order_infos)
+        result.set_data normalized_data
+      else
+        result.set_data []
+      end
+      result
+    end
+
+    def new_orders(params)
+      params = normalize_request_data params
+      params[:OrderCount] = params[:Order].is_a?(Array) ? params[:Order].length : 1
+      params = { DeliveryRequest: params }
+      result = authorized_request url_for(:primary, :new_orders), url_for(:secondary, :new_orders), params
+      if result.errors.any?
+        result.set_data []
+        return result
+      end
+      normalized_data = []
+      if result.data[:response].has_key? :DeliveryRequest
+        Util.array_wrap(result.data[:response][:DeliveryRequest]).each do |error_data|
+          error = CdekClient.get_api_error error_data[:ErrorCode], error_data[:Msg]
+          result.add_error error
+        end
+      end
+      if result.data[:response].has_key? :Order
+        Util.array_wrap(result.data[:response][:Order]).each do |order_data|
+          if order_data.has_key? :ErrorCode
+            error = CdekClient.get_api_error order_data[:ErrorCode], order_data[:Msg]
+            result.add_error error
+          elsif order_data.has_key? :Number
+            normalized_order_data = normalize_response_data order_data, response_normalization_rules_for(:new_orders)
+            normalized_data.push normalized_order_data
+          end
+        end
+      end
+      result.set_data normalized_data
+      result
+    end
+
+    def new_schedule(params)
+      params = normalize_request_data params
+      params[:OrderCount] = params[:Order].is_a?(Array) ? params[:Order].length : 1
+      params = { ScheduleRequest: params }
+      result = authorized_request url_for(:primary, :new_schedule), url_for(:secondary, :new_schedule), params
+      if result.errors.any?
+        result.set_data []
+        return result
+      end
+      normalized_data = []
+      if result.data[:response].has_key? :Order
+        Util.array_wrap(result.data[:response][:Order]).each do |error_data|
+          error = CdekClient.get_api_error error_data[:ErrorCode], error_data[:Msg]
+          result.add_error error
+        end
+      end
+      if result.data[:response].has_key? :ScheduleRequest
+        Util.array_wrap(result.data[:response][:ScheduleRequest]).each do |schedule_data|
+          if schedule_data.has_key? :ErrorCode
+            error = CdekClient.get_api_error schedule_data[:ErrorCode], schedule_data[:Msg]
+            result.add_error error
+          elsif schedule_data.has_key? :Msg
+            normalized_schedule_data = normalize_response_data schedule_data, response_normalization_rules_for(:new_schedule)
+            normalized_data.push normalized_schedule_data
+          end
+        end
+      end
+      result.set_data normalized_data
+      result
+    end
+
+    def call_courier(params)
+      params = normalize_request_data params
+      params[:CallCount] = params[:Call].is_a?(Array) ? params[:Call].length : 1
+      params = { CallCourier: params }
+      result = authorized_request url_for(:primary, :call_courier), url_for(:secondary, :call_courier), params
+      if result.errors.any?
+        result.set_data []
+        return result
+      end
+      normalized_data = []
+      if result.data[:response].has_key? :CallCourier
+        Util.array_wrap(result.data[:response][:CallCourier]).each do |error_data|
+          next unless error_data.has_key?(:ErrorCode)
+          error = CdekClient.get_api_error error_data[:ErrorCode], error_data[:Msg]
+          result.add_error error
+        end
+      end
+      if result.data[:response].has_key? :Call
+        Util.array_wrap(result.data[:response][:Call]).each do |call_data|
+          if call_data.has_key? :ErrorCode
+            error = CdekClient.get_api_error call_data[:ErrorCode], call_data[:Msg]
+            result.add_error error
+          elsif call_data.has_key? :Number
+            normalized_call_data = normalize_response_data call_data, response_normalization_rules_for(:call_courier)
+            normalized_data.push normalized_call_data
+          end
+        end
+      end
+      result.set_data normalized_data
+      result
+    end
+
+    def delete_orders(params)
+      params = normalize_request_data params
+      params[:OrderCount] = params[:Order].is_a?(Array) ? params[:Order].length : 1
+      params = { DeleteRequest: params }
+      result = authorized_request url_for(:primary, :delete_orders), url_for(:secondary, :delete_orders), params
+      # Currently API returns '500 - internal server error' for some invalid requests here.
+      # Continue processing data if it is such error but response data is present 
+      if result.errors.any? && (result.errors.length > 1 || result.errors[0].code != 500 || !result.data.is_a?(Hash) || !result.data.has_key?(:response))
+        result.set_data []
+        return result
+      end
+
+      normalized_data = []
+      Util.array_wrap(result.data[:response][:DeleteRequest]).each do |delete_data|
+        if delete_data.has_key? :ErrorCode
+          error = CdekClient.get_api_error delete_data[:ErrorCode], delete_data[:Msg]
+          result.add_error error
+        elsif delete_data.has_key? :Number
+          normalized_delete_data = normalize_response_data delete_data, response_normalization_rules_for(:delete_orders)
+          normalized_data.push normalized_delete_data
+        end
+      end
+      result.set_data normalized_data
+      result
+    end
+
+    def orders_print(params)
+      params = normalize_request_data params
+      params[:OrderCount] = params[:Order].is_a?(Array) ? params[:Order].length : 1
+      params = build_authorized_request_params OrdersPrint: params
+      result = raw_request url_for(:primary, :orders_print), url_for(:secondary, :orders_print), :post, {}, params
+      errors_hash = Util.xml_to_hash(result.data) rescue nil
+      if !errors_hash.nil? && errors_hash.has_key?(:response)
+        [:OrdersPrint, :Order].each do |key|
+          Util.array_wrap(errors_hash[:response][key]).each do |error_data|
+            next unless error_data.has_key?(:ErrorCode)
+            error = CdekClient.get_api_error error_data[:ErrorCode], error_data[:Msg]
+            result.add_error error
+          end
+        end
+        result.set_data nil
+      end
+      result
+    end
+
+    def calculate_price(params)
+      calculator.calculate params
+    end
+
+    private
+
+    def authorized_request(url, retry_url, params = {})
+      params = build_authorized_request_params params
+      request url, retry_url, :post, params
+    end
+
+    def request(url, retry_url, method, params = {})
+      result = raw_request url, retry_url, method, {}, params
+      if !Util.blank? result.data
+        result.set_data Util.xml_to_hash(result.data)
+      end
+      result
+    end
+
+    def build_authorized_request_params(params)
+      root_key = params.keys.first
+      formatted_date = CdekClient.format_date Time.now.utc 
+      secure = CdekClient.generate_secure formatted_date, @password
+      params = {
+        root_key => params[root_key].merge(
+          Date: formatted_date,
+          Account: @account,
+          Secure: secure
+        )
+      }
+      { xml_request: Util.hash_to_xml(params) }
+    end
+
+    def calculator
+      @calculator ||= CalculatorClient.new @account, @password
+    end
+
+  end
+end