axiomus_api 0.1

data/lib/axiomus_api/request/status_request.rb

@@ -0,0 +1,5 @@
+require_relative 'request'
+
+class AxiomusApi::StatusRequest < AxiomusApi::Request
+  xml_field :okey
+end

data/lib/axiomus_api/response/order_response.rb

@@ -0,0 +1,29 @@
+require 'nokogiri'
+
+class AxiomusApi::OrderResponse
+  attr_accessor :okey
+  attr_accessor :object_id
+  attr_accessor :code
+  attr_accessor :description
+  attr_accessor :price
+  attr_accessor :request
+
+  def initialize(xml)
+    doc = Nokogiri::XML(xml)
+    @request = doc.xpath('response/request').text
+    @okey = doc.xpath('response/auth').text
+    @object_id = doc.xpath('response/auth/@objectid').text
+    @code = doc.xpath('response/status/@code').text.to_i
+    @description = doc.xpath('response/status').text
+    @price = doc.xpath('response/status/@price').text
+  end
+
+  def error_message
+    @description unless success?
+  end
+
+  def success?
+    @code == AxiomusApi::ResponseCodes::SUCCESS
+  end
+end
+

data/lib/axiomus_api/response/regions_response.rb

@@ -0,0 +1,54 @@
+require 'nokogiri'
+
+class AxiomusApi::RegionsResponse
+  class City
+    attr_accessor :code
+    attr_accessor :name
+
+    def initialize(node)
+      @code = node.xpath('@city_code').text.to_i
+      @name = node.text
+    end
+  end
+
+  class Office
+    attr_accessor :code
+    attr_accessor :city_code
+    attr_accessor :name
+
+    def initialize(node)
+      @code = node.xpath('@office_code').text.to_i
+      @city_code = node.xpath('@city_code').text.to_i
+      @name = node.text
+    end
+  end
+
+  class Region
+    attr_accessor :code
+    attr_accessor :name
+    attr_accessor :courier
+    attr_accessor :pickup
+
+    def initialize(node)
+      @code = node.xpath('@region_code').text
+      @name = node.xpath('@name').text
+      @courier = node.xpath('courier/city').map do |n|
+        City.new(n)
+      end
+
+      @pickup = node.xpath('pickup/office').map do |n|
+        Office.new(n)
+      end
+    end
+  end
+
+  attr_accessor :regions
+
+  def initialize(xml)
+    doc = Nokogiri::XML(xml)
+
+    @regions = doc.xpath('response/region').map do |node|
+      Region.new(node)
+    end
+  end
+end

data/lib/axiomus_api/response/status_response.rb

@@ -0,0 +1,84 @@
+require 'nokogiri'
+
+class AxiomusApi::StatusResponse
+  class Order
+    attr_accessor :id
+    attr_accessor :inner_id
+    attr_accessor :price
+
+    def initialize(node)
+      @id = node.xpath('@id').text
+      @inner_id = node.xpath('@inner_id').text
+      @price = node.xpath('@price').text.to_f
+    end
+  end
+
+  class Status
+    attr_accessor :code
+    attr_accessor :description
+
+    def initialize(node)
+      @code = node.xpath('@code').text.to_i
+      @description = node.text
+    end
+  end
+
+  class PostStatus
+    attr_accessor :tracking
+    attr_accessor :postprice
+
+    def initialize(node)
+      @tracking = node.xpath('@tracking').text
+      @postprice = node.xpath('@postprice').text.to_f
+    end
+  end
+
+  class Pack
+    attr_accessor :number
+    attr_accessor :places
+    attr_accessor :status
+
+    def initialize(node)
+      @number = node.xpath('@number').text
+      @places = node.xpath('@places').text.to_i
+      @status = node.xpath('@status').text.to_i
+    end
+  end
+
+  class Item
+    attr_accessor :name
+    attr_accessor :quantity
+    attr_accessor :price
+
+    def initialize(node)
+      @name = node.xpath('@name').text
+      @quantity = node.xpath('@quantity').text.to_i
+      @price = node.xpath('@price').text.to_f
+    end
+  end
+
+  attr_accessor :d_date
+  attr_accessor :refused_items
+  attr_accessor :poststatus
+  attr_accessor :packs
+  attr_accessor :order
+  attr_accessor :status
+  attr_accessor :code
+
+  def initialize(xml)
+    doc = Nokogiri::XML(xml)
+
+    xml_date = doc.xpath('response/d_date')
+    @d_date = Date.parse(xml_date.text) unless xml_date.empty?
+    @order = Order.new(doc.xpath('response/order'))
+    @refused_items = doc.xpath('response/refused_items/item').map do |node|
+      Item.new(node)
+    end
+    @poststatus = PostStatus.new(doc.xpath('response/poststatus'))
+    @packs = doc.xpath('response/packs/pack').map do |node|
+      Pack.new(node)
+    end
+    @status = Status.new(doc.xpath('response/status'))
+  end
+end
+

data/lib/axiomus_api/response_codes.rb

@@ -0,0 +1,24 @@
+module AxiomusApi::ResponseCodes
+  SUCCESS = 0
+  ERR_AUTH_UKEY = 1
+  ERR_CHECKSUM = 2
+  ERR_NAME_ADDR_MKAD = 3
+  ERR_DELIVERY_DATE = 4
+  ERR_CONTACTS = 5
+  ERR_SERVICES = 6
+  ERR_ITEMS = 7
+  ERR_WRONG_XML = 8
+  ERR_AUTH_NO_AUTH = 9
+  ERR_AUTH_WRONG_AUTH = 10
+  ERR_AUTH_UID = 11
+  ERR_DETAIL_INVOICE_NOT_FOUND = 12
+  ERR_WRONG_CLIENT_PROFILE = 13
+  ERR_RECEPIENT = 14
+  ERR_SMS_NUM = 15
+  ERR_PHONE_NUM = 16
+  ERR_CONTRACT = 17
+  ERR_POSTAL_CODE = 18
+  ERR_NO_AGENT_CONTRACT = 19
+  ERR_INVOICE_NOT_FOUND = 20
+  ERR_QUOTE_EXCEEDED = 21
+end

data/lib/axiomus_api/serializable.rb

@@ -0,0 +1,55 @@
+require 'nokogiri'
+
+module AxiomusApi::Serializable
+  def to_xml(xml_header = false, tag_name = nil)
+    serializable_fields = self.class.attribute_meta
+    attribute_fields = serializable_fields.select{|k,v| v[:xml_type] == :attribute}
+
+    attributes = Hash[attribute_fields.map do |k,v|
+      [v[:xml_name] || k, self.send(k).to_s]
+    end].reject{|k,v| v.nil? || v.empty?}
+
+    builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+      xml.send(tag_name || self.tag_name, attributes) {
+        serializable_fields.each do |f, opt|
+          next if opt[:xml_type] == :attribute
+          xml_name = opt[:xml_name] || f
+          xml_type = opt[:xml_type] || :element
+          val = self.send(f)
+
+          next if val.nil?
+
+          case xml_type
+          when :element
+            obj_to_xml(xml, val, xml_name)
+          when :text
+            xml.text(val)
+          end
+        end
+      }
+    end
+
+    if xml_header
+      builder.to_xml
+    else
+      builder.doc.root.to_xml
+    end
+  end
+
+  private
+
+  def obj_to_xml(xml, obj, xml_name = nil)
+    if obj.respond_to?(:to_xml)
+      xml << obj.to_xml(false, xml_name)
+    elsif obj.kind_of?(Array)
+      xml.send(xml_name) {
+        obj.each{|el| obj_to_xml(xml, el)}
+      }
+    else
+      xml.send(xml_name) {
+        xml.text(obj.to_s)
+      }
+    end
+  end
+
+end

data/lib/axiomus_api/services/export_services.rb

@@ -0,0 +1,7 @@
+require_relative '../base'
+
+class AxiomusApi::ExportServices < AxiomusApi::Base
+
+  xml_attribute :transit, :warrant, optional: true
+
+end

data/lib/axiomus_api/services/post_services.rb

@@ -0,0 +1,7 @@
+require_relative '../base'
+
+class AxiomusApi::PostServices < AxiomusApi::Base
+
+  xml_attribute :valuation, :fragile, :cod, :big, optional: true
+
+end

data/lib/axiomus_api/services/region_services.rb

@@ -0,0 +1,7 @@
+require_relative '../base'
+
+class AxiomusApi::RegionServices < AxiomusApi::Base
+
+  xml_attribute :cheque, :not_open, :extrapack, :big, optional: true
+
+end

data/lib/axiomus_api/services/services.rb

@@ -0,0 +1,7 @@
+require_relative '../base'
+
+class AxiomusApi::Services < AxiomusApi::Base
+
+  xml_attribute :cash, :cheque, :card, :big, optional: true
+
+end

data/lib/axiomus_api/session.rb

@@ -0,0 +1,109 @@
+require 'net/http'
+require_relative 'actions'
+require_relative 'response/regions_response'
+require_relative 'response/status_response'
+require_relative 'response/order_response'
+
+class AxiomusApi::Session
+  include AxiomusApi::Actions
+
+  attr_reader :test
+
+  def initialize(uid, ukey, test = true)
+    @test = test
+    @uid = uid
+    @ukey = ukey
+
+    if(block_given?)
+      yield self
+    end
+  end
+
+  ['', '_carry', '_export', '_self_export', '_post', '_dpd',
+   '_ems', '_region_courier', '_region_pickup'].each do |suffix|
+    [:new, :update].each do |prefix|
+      m_name = "#{prefix}#{suffix}".to_sym
+      define_method("#{prefix}#{suffix}") do |order|
+        send_order_request(m_name, order)
+      end
+    end
+  end
+
+  def get_regions()
+    xml_request = create_request(:get_regions)
+    xml_request.auth.ukey = @ukey
+    response = send_request(xml_request)
+    AxiomusApi::RegionsResponse.new (response.body)
+  end
+
+  def status(okey)
+    xml_request = create_request(:status)
+    xml_request.auth = nil
+    xml_request.okey = okey
+    response = send_request(xml_request)
+    status_response = AxiomusApi::StatusResponse.new(response.body)
+    status_response
+  end
+
+  def send_order_request(mode, order)
+    if(!order.valid?)
+      error_msg = order.validation_errors.join('\n')
+      logger.error(error_msg)
+      raise AxiomusApi::Errors::ValidationError.new, order.validation_errors.join(error_msg)
+    end
+
+    xml_request = get_order_request(mode, order)
+    response = send_request(xml_request)
+    order_response = AxiomusApi::OrderResponse.new(response.body)
+
+    if !order_response.success?
+      log_response_error(order_response.error_message, xml_request.to_xml, response.body)
+      raise AxiomusApi::Errors::RequestError.new(order_response.code), order_response.error_message
+    end
+
+    order_response
+  end
+
+  private
+
+  def get_order_request(mode, order)
+    xml_request = create_request(mode)
+    xml_request.auth.ukey = @ukey
+    xml_request.order = order
+    xml_request.prepare_checksum(@uid)
+    xml_request
+  end
+
+  def send_request(xml_request)
+    connection = Net::HTTP.new(AxiomusApi::AXIOMUS_HOST, AxiomusApi::AXIOMUS_PORT)
+    http_request = get_http_request(xml_request)
+    logger.info("Request to #{xml_request.mode}")
+    logger.debug("Request body: #{xml_request.to_xml}")
+    response = connection.request(http_request)
+    response.body.gsub!(/^.*<?xml/, '<?xml')
+    logger.info("Response: #{response.code}")
+    logger.debug("Response raw: #{response.body}")
+    response
+  end
+
+  def api_path
+    @test ? AxiomusApi::AXIOMUS_TEST_PATH : AxiomusApi::AXIOMUS_PROD_PATH
+  end
+
+  def get_http_request(xml_request)
+    res = ::Net::HTTP::Post.new(api_path)
+    res.body = "data=#{xml_request.to_xml(true)}"
+    res
+  end
+
+  def logger
+    ::AxiomusApi.logger
+  end
+
+  def log_response_error(description, xml_request, xml_response)
+    logger.error(description)
+    logger.error("Request body: #{xml_request}")
+    logger.error("Response raw: #{xml_response}")
+  end
+
+end

data/lib/axiomus_api/validated.rb

@@ -0,0 +1,32 @@
+module AxiomusApi::Validated
+  attr_reader :validation_errors
+
+  def valid?
+    @validation_errors = []
+    return true unless kind_of? ::AxiomusApi::Base
+
+    self.class.attribute_meta.each do |k, v|
+      val = self.send(k)
+      validate_field(k, val, v)
+    end
+
+    return !@validation_errors.any?
+  end
+
+  private
+
+  def validate_field(field, value, options)
+    if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      if !options[:optional]
+        @validation_errors << "Field #{field} is required"
+      end
+    else
+      if !(options[:type].nil? || value.is_a?(options[:type]))
+        @validation_errors << "Field #{field} must be of type #{options[:type]}"
+      elsif value.respond_to?(:valid?) && !value.valid?
+        @validation_errors += value.validation_errors.map{|ve| "#{field} -> #{ve}"}
+      end
+    end
+  end
+
+end

data/lib/axiomus_api/version.rb

@@ -0,0 +1,3 @@
+module AxiomusApi
+  VERSION = '0.1'
+end

data/lib/axiomus_api.rb

@@ -0,0 +1,34 @@
+require 'logger'
+
+module AxiomusApi
+  AXIOMUS_PROD_PATH = '/hydra/api_xml.php'
+  AXIOMUS_TEST_PATH = '/test/api_xml_test.php'
+  AXIOMUS_HOST = 'axiomus.ru'
+  AXIOMUS_PORT = 80
+  AXIOMUS_TEST_CREDENTIALS = {ukey: 'XXcd208495d565ef66e7dff9f98764XX', uid: '92'}
+
+  @logger = Logger.new($stdout)
+  @logger.level = Logger::INFO
+
+  def self.logger=(val)
+    @logger = val
+  end
+
+  def self.logger
+    @logger
+  end
+
+  def self.test_session(&block)
+    session = AxiomusApi::Session.new(AXIOMUS_TEST_CREDENTIALS[:uid], AXIOMUS_TEST_CREDENTIALS[:ukey], true, &block)
+  end
+
+end
+
+require_relative('axiomus_api/actions')
+require_relative('axiomus_api/errors')
+require_relative('axiomus_api/response_codes')
+
+Dir.glob(File.join(File.dirname(__FILE__),'axiomus_api/**/*.rb')).each do |file|
+  require_relative(file)
+end
+

data/spec/factories.rb

@@ -0,0 +1,200 @@
+#coding: utf-8
+
+FactoryGirl.define do
+  sequence :inner_id do |n|
+    n
+  end
+
+  sequence :sms do |n|
+    (79030000000+n).to_s
+  end
+
+  sequence :boolean do
+    ['yes', 'no'][rand(0..1)]
+  end
+
+  factory :item, class: AxiomusApi::Item do
+    name {"Product #{rand(1..1000)}"}
+    weight {rand(0.1..10.0)}
+    quantity {rand(1..10)}
+    price {rand(0.5..10000.0)}
+  end
+
+  factory :export_item, class: AxiomusApi::ExportItem, parent: :item do
+    oid {rand(10000..99999)}
+  end
+
+  factory :services, class: AxiomusApi::Services do
+    cash {generate :boolean}
+    cheque {generate :boolean}
+    card {generate :boolean}
+    big {generate :boolean}
+  end
+
+  factory :export_services, class: AxiomusApi::ExportServices do
+    transit {generate :boolean}
+    warrant {generate :boolean}
+  end
+
+  factory :post_services, class: AxiomusApi::PostServices do
+    valuation {generate :boolean}
+    fragile {generate :boolean}
+    cod {generate :boolean}
+    big {generate :boolean}
+  end
+
+  factory :region_services, class: AxiomusApi::RegionServices do
+    cheque {generate :boolean}
+    not_open {generate :boolean}
+    extrapack {generate :boolean}
+    big {generate :boolean}
+  end
+
+  factory :base_order, class: AxiomusApi::BaseOrder do
+    contacts 'John Galt'
+    description 'Awesome description'
+    inner_id {rand(1..2)==2 ? generate(:inner_id) : nil}
+    name 'John Galt'
+
+    trait :has_okey do
+      okey '2e3023c3e78f4f0c8cbb81257743c2d7'
+    end
+
+    places {rand(1..2)}
+    services {build(:services)}
+
+    after(:build) do |order|
+      rand(1..10).times do
+        order.items << build(:item)
+      end
+    end
+  end
+
+  factory :post_address, class: AxiomusApi::PostAddress do
+    index '344018'
+    region 'обл Ростовская'
+    area 'Ростов-на-Дону'
+    p_address 'пер. Соборный, д61, кв21'
+  end
+
+  factory :ems_address, class: AxiomusApi::EmsAddress do
+    index '344018'
+    area 'Ростов-на-Дону'
+    street 'пер Соборный'
+    house '61'
+    apartment '21'
+  end
+
+  factory :dpd_address, class: AxiomusApi::DpdAddress, parent: :ems_address do
+    region 'обл Ростовская'
+  end
+
+  factory :region_courier_address, class: AxiomusApi::RegionCourierAddress do
+    region_code 33
+    city_code 29
+    index '344018'
+    street 'пер. Соборный'
+    house 61
+    apartment 21
+  end
+
+  factory :region_pickup_address, class: AxiomusApi::RegionPickupAddress do
+    office_code 32
+  end
+
+  factory :order, class: AxiomusApi::Order, parent: :base_order do
+    trait :incl_delivery_sum do
+      incl_delivery_sum rand(100.0..200.00)
+    end
+
+    sms {rand(1..2) ? generate(:sms) : nil}
+    d_date {Time.now + rand(1..10)*24*60*60}
+    b_time {rand(10..19)}
+    e_time {b_time + 3}
+    address 'Москва, Живописная, д4 корп1, кв 16'
+    city 0
+    garden_ring {generate :boolean}
+    from_mkad {rand(1..2) == 2 && garden_ring !='yes' && city > 0 ? rand(1..40) : nil}
+  end
+
+  factory :carry_order, class: AxiomusApi::CarryOrder, parent: :base_order do
+    sms {rand(1..2) ? generate(:sms) : nil}
+    office {[0, 1, nil][rand(0..2)]}
+    b_date {Time.now + rand(5..10)*24*60*60}
+    e_date {b_date + 7*24*60*60}
+  end
+
+  factory :export_order, class: AxiomusApi::ExportOrder, parent: :base_order do
+    export_quantity {rand(1..3)}
+    transit {generate :boolean}
+    d_date {Time.now + rand(1..10)*24*60*60}
+    b_time {rand(10..19)}
+    e_time {b_time + 3}
+    services {build(:export_services)}
+    address 'Москва, Живописная, д4 корп1, кв 16'
+    garden_ring {generate :boolean}
+    from_mkad {garden_ring == 'yes' ? nil : rand(1..40)}
+
+    after(:build) do |order|
+      order.items = []
+      rand(1..10).times do
+        order.items << build(:export_item)
+      end
+    end
+  end
+
+  factory :self_export_order, class: AxiomusApi::SelfExportOrder, parent: :base_order do
+    car 'с065мк61'
+    d_date {Time.now + rand(1..10)*24*60*60}
+    b_time {rand(10..19)}
+    e_time {b_time + 3}
+    quantity {rand(1..3)}
+
+    after(:build) do |order|
+      order.items = []
+      rand(1..10).times do
+        order.items << build(:export_item)
+      end
+    end
+  end
+
+  factory :post_order, class: AxiomusApi::PostOrder, parent: :base_order do
+    d_date {Time.now + rand(1..10)*24*60*60}
+    post_type {rand(1..2)}
+    address {build(:post_address)}
+    services {build(:post_services)}
+    contacts {generate(:sms)}
+  end
+
+  factory :ems_order, class: AxiomusApi::EmsOrder, parent: :base_order do
+    d_date {Time.now + rand(1..10)*24*60*60}
+    address {build(:ems_address)}
+    services {build(:post_services)}
+    contacts {generate(:sms)}
+  end
+
+  factory :region_order, class: AxiomusApi::RegionOrder, parent: :base_order do
+    d_date {(Time.now + rand(5..15)*24*60*60).strftime('%Y-%m-%d')}
+    b_time {rand(10..17)}
+    e_time {b_time + 1}
+    services {build(:region_services)}
+  end
+
+  factory :region_courier_order, class: AxiomusApi::RegionCourierOrder, parent: :region_order do
+    address {build(:region_courier_address)}
+  end
+
+  factory :region_pickup_order, class: AxiomusApi::RegionPickupOrder, parent: :region_order do
+    address {build(:region_pickup_address)}
+  end
+
+  factory :dpd_order, class: AxiomusApi::DpdOrder, parent: :base_order do
+    post_type {rand(1..2)}
+    services {build(:post_services)}
+    address {build(:dpd_address)}
+    d_date {(Time.now + rand(5..15)*24*60*60).strftime('%Y-%m-%d')}
+    b_time {rand(10..17)}
+    e_time {b_time + 1}
+  end
+
+end