collector-ruby 0.1.1

data/lib/collector/address.rb

@@ -0,0 +1,28 @@
+require 'representable/hash'
+
+module Collector
+  class Address < BaseModel
+    attributes :address1, :city,
+      :country_code, :postal_code
+    attributes_opt :address2, :co_address, :cell_phone_number,
+      :company_name, :email, :first_name,
+      :last_name, :phone_number
+  end
+
+  class AddressRepresenter < Representable::Decorator
+    include Representable::Hash
+
+    property :address1,           as: :Address1
+    property :address2,           as: :Address2
+    property :co_address,         as: :COAddress
+    property :city,               as: :City
+    property :country_code,       as: :CountryCode
+    property :postal_code,        as: :PostalCode
+    property :cell_phone_number,  as: :CellPhoneNumber
+    property :company_name,       as: :CompanyName
+    property :email,              as: :Email
+    property :first_name,         as: :Firstname
+    property :last_name,          as: :Lastname
+    property :phone_number,       as: :PhoneNumber
+  end
+end

data/lib/collector/adjust_invoice_request.rb

@@ -0,0 +1,28 @@
+require 'representable/hash'
+require 'representable/hash/collection'
+
+module Collector
+  class AdjustInvoiceRequest < BaseModel
+
+    attributes :invoice_no, :article_id,
+                :description, :amount, :vat,
+                :store_id, :country_code
+    attributes_opt :correlation_id
+  end
+
+  class AdjustInvoiceRequestRepresenter < Representable::Decorator
+    include Representable::Hash
+
+    self.representation_wrap = "AdjustInvoiceRequest"
+
+    property   :amount,          as: "Amount"
+    property   :article_id,      as: "ArticleId"
+    property   :description,     as: "Description"
+    property   :correlation_id,  as: "CorrelationId"
+    property   :country_code,    as: "CountryCode"
+    property   :invoice_no,      as: "InvoiceNo"
+    property   :store_id,        as: "StoreId"
+    property   :vat,             as: "Vat"
+  end
+
+end

data/lib/collector/article_list_item.rb

@@ -0,0 +1,28 @@
+module Collector
+  class ArticleListItem < BaseModel
+    attributes :article_id, :quantity, :description
+
+    def initialize(hash_or_invoice_row = {})
+      if hash_or_invoice_row.kind_of? Hash
+        super(hash_or_invoice_row)
+      elsif hash_or_invoice_row.kind_of? InvoiceRow
+        hash = attributes.inject({}) do |memo, attr|
+          memo[attr] = hash_or_invoice_row.send(attr)
+          memo
+        end
+        super(hash)
+      else
+        raise ArgumentError.new("An ArticleListItem must be initialized with a hash or an InvoiceRow instance.")
+      end
+    end
+  end
+
+  class ArticleListItemRepresenter < Representable::Decorator
+    include Representable::Hash
+
+    property :article_id,      as: "ArticleId"
+    property :quantity,        as: "Quantity"
+    property :description,     as: "Description"
+  end
+
+end

data/lib/collector/base_model.rb

@@ -0,0 +1,116 @@
+module Collector
+
+  class BaseModel
+    @swallow_unsupported_attributes = false
+
+    class << self
+      def attributes(*args)
+        @attributes ||= []
+        @attributes += args
+        args.each{|attr| attr_accessor attr }
+      end
+      def attributes_opt(*args)
+        @attributes_opt ||= []
+        @attributes_opt += args
+        args.each{|attr| attr_accessor attr }
+      end
+
+      alias_method :attribute, :attributes
+      alias_method :attribute_opt, :attributes_opt
+
+      def swallow_unsupported_attributes
+        @swallow_unsupported_attributes = true
+      end
+
+      def swallow_unsupported_attributes?
+        @swallow_unsupported_attributes
+      end
+    end
+
+    def attributes
+      self.class.instance_variable_get("@attributes") || []
+    end
+
+    def attributes_opt
+      self.class.instance_variable_get("@attributes_opt") || []
+    end
+
+    def all_attributes
+      attributes + attributes_opt
+    end
+
+    def validate_input(hash)
+      unsupported_keys = hash.keys.map(&:to_sym) - all_attributes
+      unless unsupported_keys.empty?
+        raise ArgumentError.new("Unsupported attribute(s): #{unsupported_keys}")
+      end
+    end
+
+    def initialize(hash = {})
+      validate_input(hash) unless self.class.swallow_unsupported_attributes?
+      all_attributes.each do |attr|
+        val = hash[attr] || hash[attr.to_s]
+        self.send("#{attr}=", val)
+      end
+    end
+
+    def ==(other)
+      self.class.attributes.each do |attr|
+        return false if self.send(attr) != other.send(attr)
+      end
+      true
+    end
+
+    def has_required_attributes?
+      missing_attributes.empty?
+    end
+
+    def missing_attributes
+      own_missing + nested_missing
+    end
+
+    def own_missing
+      attributes.select{|attr| send(attr).nil? }
+    end
+
+    def nested_missing
+      missing = []
+      all_attributes.each do |attr|
+        val = send(attr)
+        if !!val
+          if val.kind_of? BaseModel
+            nested_missing = val.missing_attributes
+            missing << {attr => nested_missing} unless nested_missing.empty?
+          elsif val.kind_of? Array
+            val.each_with_index do |nested_val, index|
+              if nested_val.kind_of? BaseModel
+                nested_missing = nested_val.missing_attributes
+                missing << {"#{attr}[#{index}]" => nested_missing} unless nested_missing.empty?
+              end
+            end
+          end
+        end
+      end
+      missing
+    end
+
+    def missing_attributes_human_readable(prefix = "", missing_attr = nil)
+      missing_attr = missing_attributes if missing_attr.nil?
+      missing_key_paths = missing_attr.map.each_with_index do |item|
+        if item.kind_of? Hash
+          key = item.keys.first
+          missing_attributes_human_readable(prefix + "#{key}.", item[key])
+        else
+          "#{prefix}#{item}"
+        end
+      end
+      if prefix.empty?
+        "Missing attributes: " + missing_key_paths.flatten.join(", ")
+      else
+        missing_key_paths
+      end
+    end
+
+  end
+
+end

data/lib/collector/cancel_invoice_request.rb

@@ -0,0 +1,22 @@
+require 'representable/hash'
+require 'representable/hash/collection'
+
+module Collector
+  class CancelInvoiceRequest < BaseModel
+
+    attributes :invoice_no, :store_id, :country_code
+    attributes_opt :correlation_id
+  end
+
+  class CancelInvoiceRequestRepresenter < Representable::Decorator
+    include Representable::Hash
+
+    self.representation_wrap = "CancelInvoiceRequest"
+
+    property   :correlation_id,           as: "CorrelationId"
+    property   :country_code,             as: "CountryCode"
+    property   :invoice_no,               as: "InvoiceNo"
+    property   :store_id,                 as: "StoreId"
+  end
+
+end

data/lib/collector/client.rb

@@ -0,0 +1,133 @@
+require 'savon'
+require 'active_support/core_ext'
+
+module Collector
+
+  COLLECTOR_URL       =  'https://ecommerce.collector.se/v3.0/InvoiceServiceV31.svc?wsdl'
+  COLLECTOR_URL_TEST  =  'https://eCommerceTest.collector.se/v3.0/InvoiceServiceV31.svc?wsdl'
+  SERVICE_NAME        =   :InvoiceServiceV31
+  PORT_NAME           =   :BasicHttpBinding_IInvoiceServiceV31
+
+  class CollectorError < RuntimeError
+    attr_reader :faultcode
+    def initialize(faultcode, message)
+      super(message)
+      @faultcode = faultcode
+    end
+  end
+
+  class InvoiceNotFoundError < CollectorError ; end
+  class InvalidInvoiceStatusError < CollectorError ; end
+  class InvalidTransactionAmountError < CollectorError ; end
+  class AuthorizationFailedError < CollectorError ; end
+
+  class Client
+    def initialize(user_name, password, sandbox = false)
+      @header = {"ClientIpAddress" => "?",
+                      "Username" => user_name,
+                      "Password" => password }
+      url = sandbox ? COLLECTOR_URL_TEST : COLLECTOR_URL
+      http = Savon::HTTPClient.new
+      http.client.ssl_config.ssl_version = 'TLSv1'
+      @savon = Savon.new(url, http)
+    end
+
+    def operation_with_name(operation_name)
+      @savon.operation(SERVICE_NAME, PORT_NAME, operation_name).tap do |operation|
+        operation.header = @header
+      end
+    end
+
+    def raise_error(response_hash)
+      fault = response_hash[:fault]
+      err_class = CollectorError
+      case fault[:faultcode]
+      when "s:INVOICE_NOT_FOUND"
+        err_class = InvoiceNotFoundError
+      when "s:INVALID_INVOICE_STATUS"
+        err_class = InvalidInvoiceStatusError
+      when "s:INVALID_TRANSACTION_AMOUNT"
+        err_class = InvalidTransactionAmountError
+      when "s:AUTHORIZATION_FAILED"
+        err_class = AuthorizationFailedError
+      end
+      faultcode = fault[:faultcode].split(":").last
+      raise err_class.send(:new, faultcode, fault[:faultstring])
+    end
+
+    def validate_attributes(request_object)
+      unless request_object.has_required_attributes?
+        raise ArgumentError.new(request_object.missing_attributes_human_readable)
+      end
+    end
+
+    # operation_name is a symbol named as in the Collector API, eg :AddInvoice
+    # request is a hash or an object responding to to_hash
+    def perform_operation(operation_name, request)
+      operation = operation_with_name operation_name
+      operation.body = request.to_hash.with_indifferent_access
+      response = operation.call.body
+      raise_error(response) unless response[:fault].nil?
+      namespace = response.keys.first
+      response[namespace].with_indifferent_access
+    end
+
+    def add_invoice(invoice_request)
+      validate_attributes(invoice_request)
+      resp = perform_operation(:AddInvoice, InvoiceRequestRepresenter.new(invoice_request))
+      InvoiceResponse.new(resp)
+    end
+
+    def get_address(options)
+      request = GetAddressRequest.new(options.merge({country_code: "SE"}))
+      validate_attributes(request)
+      resp = perform_operation(:GetAddress, GetAddressRequestRepresenter.new(request))
+      user = User.new
+      UserRepresenter.new(user).from_hash(resp)
+      user
+    end
+
+    def cancel_invoice(options)
+      request = CancelInvoiceRequest.new(options)
+      validate_attributes(request)
+      resp = perform_operation(:CancelInvoice, CancelInvoiceRequestRepresenter.new(request))
+      resp[:correlation_id]
+    end
+
+    def adjust_invoice(options)
+      request = AdjustInvoiceRequest.new(options)
+      validate_attributes(request)
+      resp = perform_operation(:AdjustInvoice, AdjustInvoiceRequestRepresenter.new(request))
+      resp[:correlation_id]
+    end
+
+    def replace_invoice(options)
+      request = ReplaceInvoiceRequest.new(options)
+      validate_attributes(request)
+      resp = perform_operation(:ReplaceInvoice, ReplaceInvoiceRequestRepresenter.new(request))
+      InvoiceResponse.new(resp)
+    end
+
+    def activate_invoice(options)
+      request = ActivateInvoiceRequest.new(options)
+      validate_attributes(request)
+      operation = nil
+      if request.article_list.nil?
+        operation = :ActivateInvoice
+        request = ActivateInvoiceRequestRepresenter.new(request)
+      else
+        operation = :PartActivateInvoice
+        request = PartActivateInvoiceRequestRepresenter.new(request)
+      end
+      resp = perform_operation(operation, request)
+      InvoiceResponse.new(resp)
+    end
+
+    def part_activate_invoice(options)
+      if options[:article_list].nil?
+        raise ArgumentError.new("Required parameter article_list missing.")
+      end
+      activate_invoice(options)
+    end
+  end
+end

data/lib/collector/get_address_request.rb

@@ -0,0 +1,22 @@
+require 'representable/hash'
+require 'representable/hash/collection'
+
+module Collector
+  class GetAddressRequest < BaseModel
+
+    attributes :reg_no, :store_id, :country_code
+    attributes_opt :correlation_id
+  end
+
+  class GetAddressRequestRepresenter < Representable::Decorator
+    include Representable::Hash
+
+    self.representation_wrap = "GetAddressRequest"
+
+    property   :correlation_id,           as: "CorrelationId"
+    property   :country_code,             as: "CountryCode"
+    property   :reg_no,                   as: "RegNo"
+    property   :store_id,                 as: "StoreId"
+  end
+
+end

data/lib/collector/invoice_request.rb

@@ -0,0 +1,63 @@
+require 'representable/hash'
+require 'representable/hash/collection'
+
+module Collector
+  class InvoiceRequest < BaseModel
+
+    attributes :activation_option, :country_code, :currency,
+        :delivery_address, :invoice_address, :invoice_delivery_method,
+        :invoice_rows, :invoice_type, :order_date,
+        :reg_no, :store_id
+
+    attributes_opt :correlation_id, :cost_center, :credit_time, :customer_no,
+        :gender, :order_no, :product_code,
+        :purchase_type, :reference, :sales_person
+
+  end
+
+  class InvoiceRowListRepresenter < Representable::Decorator
+    include Representable::Hash::Collection
+    self.representation_wrap = "InvoiceRow"
+    items extend: InvoiceRowRepresenter, class: InvoiceRow
+  end
+
+  class InvoiceRequestRepresenter < Representable::Decorator
+    include Representable::Hash
+
+    self.representation_wrap = "AddInvoiceRequest"
+
+    property   :activation_option,        as: "ActivationOption"
+    property   :correlation_id,           as: "CorrelationId"
+    property   :cost_center,              as: "CostCenter"
+    property   :country_code,             as: "CountryCode"
+    property   :credit_time,              as: "CreditTime"
+    property   :currency,                 as: "Currency"
+    property   :customer_no,              as: "CustomerNo"
+    property   :delivery_address,         as: "DeliveryAddress",
+                                          decorator: AddressRepresenter,
+                                          class: Address
+    property   :gender,                   as: "Gender"
+    property   :invoice_address,          as: "InvoiceAddress",
+                                          decorator: AddressRepresenter,
+                                          class: Address
+    property   :invoice_delivery_method,  as: "InvoiceDeliveryMethod"
+    property   :invoice_rows,
+                  writer: lambda {|doc, args|
+                    doc["InvoiceRows"] = InvoiceRowListRepresenter.new(invoice_rows).to_hash
+                  },
+                  reader: lambda {|doc, args|
+                    rows = doc["InvoiceRows"]["InvoiceRow"]
+                    self.invoice_rows = rows.map{|row| InvoiceRowRepresenter.new(InvoiceRow.new).from_hash(row) }
+                  }
+    property   :invoice_type,             as: "InvoiceType"
+    property   :order_date,               as: "OrderDate", :type => DateTime
+    property   :order_no,                 as: "OrderNo"
+    property   :product_code,             as: "ProductCode"
+    property   :purchase_type,            as: "PurchaseType"
+    property   :reference,                as: "Reference"
+    property   :reg_no,                   as: "RegNo"
+    property   :sales_person,             as: "SalesPerson"
+    property   :store_id,                 as: "StoreId"
+  end
+
+end