klarna-xmlrpc 0.2.0

data/lib/klarna/api/errors.rb

@@ -0,0 +1,154 @@
+# encoding: utf-8
+require 'xmlrpc/client'
+
+module Klarna
+  module API
+    module Errors
+
+      ERROR_CODES = {
+        1103  => :estore_overrun,
+        1104  => :estore_blacklisted,
+        1999  => :misc_estore_error,
+        2101  => :credit,
+        2102  => :amount,
+        2103  => :customer_credit_overrun,
+        2104  => :blocked,
+        2105  => :unpaid_bills,
+        2106  => :customer_not_accepted,
+        2107  => :customer_blacklisted,
+        2201  => :pno,
+        2202  => :invalid_pno,
+        2203  => :pno_not_real_person,
+        2204  => :dead,
+        2205  => :under_aged,
+        2206  => :customer_not_18,
+        2301  => :no_such_person,
+        2302  => :customer_missing,
+        2303  => :no_such_customer,
+        2304  => :unknown_customer,
+        2305  => :bad_customer_password,
+        2401  => :tno_not_found,
+        2402  => :pin_error,
+        2403  => :wrong_pin,
+        2404  => :no_pin,
+        2405  => :orgno,
+        2999  => :misc_customer_error,
+        3101  => :foreign_addr,
+        3102  => :bad_addr,
+        3103  => :bad_address,
+        3104  => :postno,
+        3105  => :bad_postno,
+        3106  => :bad_name,
+        3107  => :address,
+        3108  => :no_address,
+        3201  => :cellno,
+        3202  => :telno,
+        3203  => :email,
+        3204  => :country,
+        3205  => :city,
+        3206  => :postno,
+        3207  => :street,
+        3208  => :client_ip,
+        3209  => :proto_vsn,
+        3210  => :goods_list,
+        3211  => :artnos,
+        3301  => :bad_name_and_address,
+        3302  => :bad_last_name,
+        3303  => :bad_first_name,
+        3304  => :bad_first_name_and_last_name,
+        3999  => :misc_submission_error,
+        6101  => :orgno_pclass_not_allowed,
+        6102  => :sum_low_for_pclass,
+        6103  => :unknown_pclass,
+        6104  => :not_annuity_pclass,
+        6999  => :misc_pclass_error,
+        7101  => :no_such_subscription,
+        7102  => :not_unique_subscription_no,
+        7103  => :terminated,
+        7104  => :already_set,
+        7105  => :need_email_addr,
+        7999  => :misc_subscription_error,
+        8101  => :unknown_invoice,
+        8102  => :negative_invoice,
+        8103  => :invoice_not_active,
+        8104  => :invoice_bad_status,
+        8105  => :invoice_is_passive,
+        8106  => :invoice_is_archived,
+        8107  => :invoice_is_suspect,
+        8108  => :invoice_is_frozen,
+        8109  => :invoice_is_pre_pay,
+        8110  => :invoice_stale,
+        8111  => :invoice_not_passive_or_frozen,
+        8112  => :invoice_in_test_mode,
+        8113  => :invoice_not_passive,
+        8114  => :invno,
+        8999  => :misc_invoice_error,
+        9101  => :cno_already_in_use,
+        9102  => :unknown_csid,
+        9103  => :not_allowed_operation,
+        9104  => :ip_from_wrong_country,
+        9105  => :bad_type,
+        9106  => :unknown_type,
+        9107  => :bad_artnolist,
+        9108  => :unknown_artno,
+        9109  => :rno,
+        9110  => :split,
+        9111  => :bad_order_no,
+        9112  => :bad_ocr,
+        9113  => :unknown_estore,
+        9114  => :invalid_estore_secret,
+        9115  => :bad_module_vsn,
+        9116  => :pno_encoding,
+        9117  => :currency,
+        9118  => :currency_country_pnoencoding,
+        9119  => :timeout
+      }.freeze
+
+      class KlarnaStandardError < ::StandardError
+        def initialize(message)
+          ::Klarna.log message, :error
+          super(message)
+        end
+      end
+
+      class KlarnaArgumentError < ::ArgumentError
+        def initialize(message)
+          ::Klarna.log message, :error
+          super(message)
+        end
+      end
+
+      class KlarnaCredentialsError < KlarnaStandardError
+      end
+
+      class KlarnaServiceError < ::XMLRPC::FaultException
+        alias :error_code :faultCode
+        alias :error_message :faultString
+
+        def initialize(error_code, error_key)
+          localized_error_message = ::Klarna::API::Errors.error_message(error_key)
+          message = ::Klarna.mode == :test ? "#{error_key} (#{[error_code, ERROR_CODES[error_code]].compact.join(' - ')})" : localized_error_message
+          ::Klarna.log message, :error
+          super(error_code, message)
+        end
+
+        def to_h
+          {:error_code => self.error_code, :error_message => self.error_message}
+        end
+      end
+
+      class << self
+
+        # Lookup localized string value for a specified error/exception code or key.
+        #
+        def error_message(id_or_key)
+          key = id_or_key.is_a?(Fixnum) ? ERROR_CODES[id_or_key] : id_or_key
+          key
+        end
+        alias :localized_error_message :error_message
+
+      end
+
+    end
+  end
+end

data/lib/klarna/api/methods.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+require 'klarna/api/methods/standard'
+require 'klarna/api/methods/invoicing'
+require 'klarna/api/methods/reservation'
+require 'klarna/api/methods/cost_calculations'
+
+module Klarna
+  module API
+    module Methods
+      include ::Klarna::API::Methods::Standard
+      include ::Klarna::API::Methods::Invoicing
+      include ::Klarna::API::Methods::Reservation
+      include ::Klarna::API::Methods::CostCalculations
+    end
+  end
+end

data/lib/klarna/api/methods/cost_calculations.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+module Klarna
+  module API
+    module Methods
+      module CostCalculations
+
+        # Purpose: Obtain pclass values from Klarna.
+        #
+        # == Note:
+        #
+        #   This function is only to be used to obtain pclass values for stores ONE TIME ONLY.
+        #   It is not allowed to use this function for continuous calculation of monthly costs or
+        #   with every purchase in the checkout. The pclass values do NOT change.
+        #
+        def fetch_pclasses(currency_code)
+          # params = [
+          #   self.store_id,
+          #   currency_code,
+          #   self.digest(currency_code)
+          # ]
+          # self.call(:fetch_pclasses, *params)
+          raise NotImplementedError
+        end
+
+        # Calculate monthly cost "in the most proper way".
+        #
+        def calculate_monthly_cost(sum, currency, pclass_id, flags = nil)
+          # # TODO: OpenStruct this
+          # pclasses = ::Klarna.store_pclasses[currency.to_s.underscore]
+          # month_count = pclasses[pclass_id][:months]
+          # monthly_fee = pclasses[pclass_id][:invoice_fee]
+          # start_fee = pclasses[pclass_id][:start_fee]
+          # rate = pclasses[pclass_id][:interest_rate]
+          # type = pclasses[pclass_id][:type] # QUESTION: Where do I get this from - not in API-call.
+          #
+          # # TODO: Call Klarna and ask where I get "type" from - not with pclasses.
+          # case type
+          # when ::Klarna::API::PClassFlags::ANNUITY
+          #   self.periodic_cost(sum, month_count, monthly_fee, start_fee, rate, currency, flags)
+          # when ::Klarna::API::PClassFlags::DIVISOR
+          #   self.monthly_cost(sum, month_count, monthly_fee, start_fee, rate, currency, flags)
+          # else
+          #   raise InvalidArgumentError, "Invalid Klarna campaign/pclass type: #{type.inspect}"
+          # end
+          raise NotImplementedError
+        end
+
+        # Calculate the monthly cost for goods which can be paid for by part payment.
+        #
+        def periodic_cost(sum, month_count, monthly_fee, start_fee, rate, currency, flags = nil)
+          # daily_rate = self.calculate_daily_rate(rate)
+          # monthly_payment = self.calculate_monthly_payment(sum + start_fee, daily_rate, month_count)
+          # monthly_cost = monthly_payment + monthly_fee
+          # monthly_cost.round
+          raise NotImplementedError
+        end
+
+        # Calculate the monthly cost for account purchases.
+        #
+        def monthly_cost(sum, month_count, monthly_fee, start_fee, rate, currency, flags = nil)
+          # interest_cost = self.calculate_interest_cost(sum, rate)
+          # period_cost = (sum + interest_cost) / month_count
+          # flags ||= ::Klarna::API::MonthlyCostFlags::LIMIT
+          #
+          # # TODO: Remove this line - after debugging.
+          # ::Klarna.log [::Klarna::API::AVERAGE_INTEREST_PERIOD, calc_rate, interest_cost, period_cost].join(', ')
+          #
+          # monthly_cost = case flags
+          #   when ::Klarna::API::MonthlyCostFlags::LIMIT
+          #     period_cost
+          #   when ::Klarna::API::MonthlyCostFlags::ACTUAL
+          #     begin
+          #       lowest_monthly_payment = ::Klarna::API::LOWEST_PAYMENT_BY_CURRENCY[currency]
+          #     rescue
+          #       raise ::Klarna::API::KlarnaStandardError,
+          #       "No such currency: #{currency.inspect}. Valid currencies: SEK:1, NOK:2, EUR:3, DKK:4"
+          #     end
+          #     period_cost += monthly_fee
+          #     (period_cost < lowest_monthly_payment) ? lowest_monthly_payment : period_cost
+          #   else
+          #     raise ::Klarna::API::KlarnaStandardError,
+          #       "Invalid flag: #{flags.inspect}. Valid flags: LIMIT:0, ACTUAL:1"
+          #       end
+          # ::Klarna.log_result("Calculation: monthly_cost = %s") do
+          #   self.round_up(monthly_cost, currency)
+          # end
+          raise NotImplementedError
+        end
+
+        protected
+
+          def calculate_interest_cost(sum, rate)
+            # rate *= 100.0 if rate < 100.0
+            # calc_rate = (rate / 10000)
+            # (::Klarna::API::AVERAGE_INTEREST_PERIOD / ::Klarna::API::DAYS_IN_A_YEAR) * calc_rate * sum
+            raise NotImplementedError
+          end
+
+          def calculate_monthly_payment(sum, daily_rate, month_count)
+            # sum = sum.to_double
+            # total_dates = (month_count - 1) * 30
+            # denominator = self.get_denominator(dailyrate, total_dates)
+            # total_dates += 60
+            # (dailyrate ** totdates) * sum / denominator
+            raise NotImplementedError
+          end
+
+          def calculate_daily_rate(rate)
+            # ((rate.to_decimal / 10000.0) + 1.0) ** (1 / ::Klarna::API::DAYS_IN_A_YEAR)
+            raise NotImplementedError
+          end
+
+          def get_denominator(daily_rate, total_dates)
+            # start_dates = 0.0
+            # sum = 1.0
+            # while total_dates > start_dates
+            #   start_dates += 30
+            #   sum += total_dates ** start_dates
+            # end
+            # sum
+            raise NotImplementedError
+          end
+
+          def round_up(amount, currency)
+            # divisor = currency == ::Klarna::API::Currencies::EUR ? 10.0 : 100.0
+            # (((divisor / 2) + amount) / divisor) #.round
+            raise NotImplementedError
+          end
+
+      end
+    end
+  end
+end

data/lib/klarna/api/methods/invoicing.rb

@@ -0,0 +1,304 @@
+# encoding: utf-8
+
+module Klarna
+  module API
+    module Methods
+      module Invoicing
+
+        # == TODO:
+        #
+        #   * #total_credit_purchase_cost
+        #
+
+        # Create an invoice.
+        #
+        def add_invoice(store_user_id, order_id, articles, shipping_fee,
+                            handling_fee, shipment_type, pno, first_name, last_name, address, client_ip,
+                            currency, country, language, pno_encoding, pclass = nil, annual_salary = nil,
+                            password = nil, ready_date = nil, comment = nil, rand_string = nil, new_password = nil, flags = nil)
+          shipment_type = ::Klarna::API.id_for(:shipment_type, shipment_type)
+          currency = ::Klarna::API.id_for(:currency, currency)
+          country = ::Klarna::API.id_for(:country, country)
+          language = ::Klarna::API.id_for(:language, language)
+          pno_encoding = ::Klarna::API.id_for(:pno_format, pno_encoding)
+          pclass = pclass ? ::Klarna::API.id_for(:pclass, pclass) : -1
+          flags = ::Klarna::API.parse_flags(:INVOICE, flags)
+          articles = Array.wrap(articles).compact
+
+          params = [
+            self.store_id,
+            store_user_id,
+            self.digest(articles.collect { |g| g[:goods][:title] }, :store_id => false),
+            order_id,
+            articles,
+            shipping_fee,
+            shipment_type,
+            handling_fee,
+            pno,
+            first_name,
+            last_name,
+            address,
+            password.to_s,
+            client_ip.to_s,
+            new_password.to_s,
+            flags.to_i,
+            comment.to_s,
+            ready_date.to_s,
+            rand_string.to_s,
+            currency,
+            country,
+            language,
+            pno_encoding,
+            pclass,
+            annual_salary.to_i
+          ]
+
+          self.call(:add_invoice, *params)
+        end
+        alias :add_transaction :add_invoice
+
+        # Activate a passive invoice - optionally only partly.
+        #
+        # == Note:
+        #
+        #   This function call cannot activate an invoice created in test mode. It is however possible
+        #   to manually activate such an invoice.
+        #
+        #   When partially activating an invoice only the articles and quantities specified by
+        #   you will be activated. A passive invoice is created containing the articles on the
+        #   original invoice not activated.
+        #
+        def activate_invoice(invoice_no, articles = nil)
+          # TODO: Parse/Validate invoice_no as :integer
+          # TODO: Parse/Valdiate articles as array of articles
+          articles = Array.wrap(articles).compact
+
+          params = [
+            self.store_id,
+            invoice_no
+          ]
+
+          # Only partly?
+          if articles.present?
+            params << articles
+            params << self.digest(invoice_no, articles.collect { |a| [a[:goods][:artno], a[:qty]].join(':') }.join(':'))
+            method = :activate_part
+          else
+            params << self.digest(invoice_no)
+            method = :activate_invoice
+          end
+
+          self.call(method, *params)
+        end
+        alias :activate_part :activate_invoice
+
+        # Delete a passive invoice.
+        #
+        def delete_invoice(invoice_no)
+          # TODO: Parse/Validate invoice_no as :integer
+
+          params = [
+            self.store_id,
+            invoice_no,
+            self.digest(invoice_no)
+          ]
+
+          self.call(:delete_invoice, *params)
+        end
+
+        # Give discounts for invoices.
+        #
+        def return_amount(invoice_no, amount, vat)
+          params = [
+            self.store_id,
+            invoice_no,
+            amount,
+            vat,
+            self.digest(invoice_no)
+          ]
+          self.call(:return_amount, *params) # raise NotImplementedError
+        end
+
+        # Return a invoice - optionally only partly.
+        #
+        def credit_invoice(invoice_no, credit_id, articles = nil)
+          articles = Array.wrap(articles).compact
+
+          params = [
+            self.store_id,
+            invoice_no,
+            credit_id,
+          ]
+
+          if articles.present? # Only partly?
+            params << articles
+            params << self.digest(invoice_no, articles.collect { |a| [a[:goods][:artno], a[:qty]].join(':') }.join(':'))
+            method = :credit_part
+          else
+            params << self.digest(invoice_no)
+            method = :credit_invoice
+          end
+
+          self.call(method, *params)
+        end
+
+        # Send an active invoice to the customer via e-mail.
+        #
+        # == Note:
+        #
+        #   Regular postal service is used if the customer lacks an e-mail address.
+        #
+        def email_invoice(invoice_no)
+          # TODO: Parse/Validate invoice_no as integer
+
+          params = [
+            self.store_id,
+            invoice_no,
+            self.digest(invoice_no)
+          ]
+
+          self.call(:email_invoice, *params)
+        end
+
+        # Request a postal send-out of an active invoice to a customer by Klarna.
+        #
+        def send_invoice(invoice_no)
+          # TODO: Parse/Validate invoice_no as integer
+
+          params = [
+            self.store_id,
+            invoice_no,
+            self.digest(invoice_no)
+          ]
+
+          self.call(:send_invoice, *params)
+        end
+
+        # Create quantity and article number (i.e. the +articles+ argument for the
+        # +activate_part+ and +credit_part+ function).
+        #
+        def make_article(quantity, article_no)
+          quantity = quantity.to_i
+          article_no = article_no.to_s
+          [quantity, article_no]
+        end
+
+        # Change the quantity of a specific item in a passive invoice.
+        #
+        def update_goods_quantity(invoice_no, article_no, new_quantity)
+          # TODO: Parse/Validate invoice_no as integer
+          # TODO: Parse/Validate article_no as string
+          # TODO: Parse/Validate new_quantity as integer
+
+          params = [
+            self.store_id,
+            self.digest(invoice_no, article_no, new_quantity, :store_id => false),
+            invoice_no,
+            article_no,
+            new_quantity
+          ]
+
+          self.call(:update_goods_qty, *params)
+        end
+
+        # Change the amount of a fee (for example the invoice fee) in a passive invoice.
+        #
+        def update_charge_amount(invoice_no, charge_type, new_amount)
+          # TODO: Parse/Validate invoice_no as integer
+          # TODO: Parse/Validate charge_type as integer/charge-type
+          # TODO: Parse/Validate new_amount as integer (or parse from decimal)
+
+          params = [
+            self.store_id,
+            self.digest(invoice_no, charge_type, new_amount),
+            invoice_no,
+            charge_type,
+            new_amount
+          ]
+
+          self.call(:update_charge_amount, *params)
+        end
+
+        # Change the store’s order number for a specific invoice.
+        #
+        def update_order_no(invoice_no, new_order_no)
+          # TODO: Parse/Validate invoice_no as integer
+          # TODO: Parse/Validate new_order_no as integer
+
+          params = [
+            self.store_id,
+            invoice_no,
+            self.digest(invoice_no, new_order_no),
+            new_order_no
+          ]
+
+          self.call(:update_orderno, *params)
+        end
+
+        # Retrieve the address for an invoice.
+        #
+        def invoice_address(invoice_no)
+          # TODO: Parse/Validate invoice_no as integer
+
+          params = [
+            self.store_id,
+            invoice_no,
+            self.digest(invoice_no)
+          ]
+
+          self.call(:invoice_address, *params).tap do |result|
+            result[5] = result[5].to_s.upcase
+          end
+        end
+        alias :get_invoice_address :invoice_address
+
+        # Retrieve the total amount of an invoice - optionally only partly.
+        #
+        def invoice_amount(invoice_no, articles = nil)
+          # TODO: Parse/Validate invoice_no as integer
+          articles = Array.wrap(articles).compact
+          artnos =
+            if articles.first.respond_to?(:key?) && articles.first.key?(:qty) && articles.first.key?(:artno)
+              articles
+            else
+              articles.collect { |a| {:artno => a[:goods][:artno], :qty => a[:qty]} }
+            end
+
+          params = [
+            self.store_id,
+            invoice_no
+          ]
+
+          # Only partly?
+          if articles.present?
+            params << artnos
+            params << self.digest(invoice_no, artnos.collect { |an| [an[:artno], an[:qty]].join(':') }.join(':'))
+            method = :invoice_part_amount
+          else
+            params << self.digest(invoice_no)
+            method = :invoice_amount
+          end
+
+          self.call(method, *params)
+        end
+        alias :get_invoice_amount :invoice_amount
+
+        # Check if invoice is paid.
+        #
+        def invoice_paid?(invoice_no)
+          # TODO: Parse/Validate invoice_no as numeric value (string)
+
+          params = [
+            invoice_no,
+            self.store_id,
+            self.digest(invoice_no)
+          ]
+
+          result = self.call(:is_invoice_paid, *params)
+          result == 'unpaid' ? false : true
+        end
+
+      end
+    end
+  end
+end