payson_api 0.3.3 → 1.0.2

data/lib/payson_api/v1/config.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module_function
+
+    PAYSON_WWW_HOST_ENDPOINT = 'https://www.payson.se'
+    PAYSON_WWW_PAY_FORWARD_URL = '/paysecure/?token=%s'
+
+    PAYSON_API_ENDPOINT = 'https://api.payson.se'
+    PAYSON_API_VERSION = '1.0'
+    PAYSON_API_PAY_ACTION = 'Pay'
+    PAYSON_API_PAYMENT_DETAILS_ACTION = 'PaymentDetails'
+    PAYSON_API_PAYMENT_UPDATE_ACTION = 'PaymentUpdate'
+    PAYSON_API_PAYMENT_VALIDATE_ACTION = 'Validate'
+
+    PAYSON_API_TEST_ENDPOINT = 'https://test-api.payson.se'
+    PAYSON_WWW_HOST_TEST_ENDPOINT = 'https://test-www.payson.se'
+
+    LOCALES = %w[SV EN FI].freeze
+    CURRENCIES = %w[SEK EUR].freeze
+    FEES_PAYERS = %w[EACHRECEIVER SENDER PRIMARYRECEIVER SECONDARYONLY].freeze
+    FUNDING_CONSTRAINTS = %w[CREDITCARD BANK INVOICE SMS].freeze
+    GUARANTEE_OFFERINGS = %w[OPTIONAL REQUIRED NO].freeze
+    PAYMENT_STATUSES = %w[CREATED PENDING PROCESSING COMPLETED CREDITED
+                          INCOMPLETE ERROR EXPIRED REVERSALERROR ABORTED].freeze
+    PAYMENT_TYPES = %w[TRANSFER GUARANTEE INVOICE].freeze
+    GUARANTEE_STATUSES = %w[WAITINGFORSEND WAITINGFORACCEPTANCE WAITINGFORRETURN
+                            WAITINGFORRETURNACCEPTANCE RETURNNOTACCEPTED NOTRECEIVED RETURNNOTRECEIVED
+                            MONEYRETURNEDTOSENDER RETURNACCEPTED].freeze
+    INVOICE_STATUSES = %w[PENDING ORDERCREATED CANCELED SHIPPED DONE CREDITED].freeze
+    PAYMENT_ACTIONS = %w[CANCELORDER SHIPORDER CREDITORDER REFUND].freeze
+
+    def configure
+      yield @config ||= Configuration.new # rubocop:disable Naming/MemoizedInstanceVariableName
+    end
+
+    def config
+      @config
+    end
+
+    class Configuration
+      attr_accessor :api_user_id, :api_password, :test_mode
+    end
+
+    configure do |config|
+      config.api_user_id = 'XXXX'
+      config.api_password = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
+    end
+
+    def test?
+      @config.test_mode || @config.api_user_id == '4'
+    end
+
+    def api_base_url
+      test? ? PAYSON_API_TEST_ENDPOINT : PAYSON_API_ENDPOINT
+    end
+
+    def forward_url(token)
+      (test? ? PAYSON_WWW_HOST_TEST_ENDPOINT : PAYSON_WWW_HOST_ENDPOINT) + PAYSON_WWW_PAY_FORWARD_URL % token
+    end
+  end
+end

data/lib/payson_api/v1/envelope.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'date'
+
+module PaysonAPI
+  module V1
+    class Envelope
+      attr_accessor :ack, :timestamp, :correlation_id
+
+      FORMAT_STRING = 'responseEnvelope.%s'
+
+      def initialize(ack, timestamp, correlation_id)
+        @ack = ack
+        @timestamp = timestamp
+        @correlation_id = correlation_id
+      end
+
+      def self.parse(data)
+        ack = data[FORMAT_STRING % 'ack']
+        timestamp = DateTime.parse(CGI.unescape(data[FORMAT_STRING % 'timestamp'].to_s))
+        correlation_id = data[FORMAT_STRING % 'correlationId']
+        new(ack, timestamp, correlation_id)
+      end
+    end
+  end
+end

data/lib/payson_api/v1/errors/unknown_currency_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Errors
+      class UnknownCurrencyError < StandardError
+        def initialize(_msg, currency)
+          super("Unknown currency: #{currency}")
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/errors/unknown_fees_payer_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Errors
+      class UnknownFeesPayerError < StandardError
+        def initialize(_msg, fees_payer)
+          super("Unknown fees payer: #{fees_payer}")
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/errors/unknown_funding_constraint_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Errors
+      class UnknownFundingConstraintError < StandardError
+        def initialize(_msg, funding_constraint)
+          super("Unknown funding constraint: #{funding_constraint}")
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/errors/unknown_guarantee_offering_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Errors
+      class UnknownGuaranteeOfferingError < StandardError
+        def initialize(_msg, guarantee_offering)
+          super("Unknown guarantee offering: #{guarantee_offering}")
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/errors/unknown_locale_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Errors
+      class UnknownLocaleError < StandardError
+        def initialize(_msg, locale)
+          super("Unknown locale: #{locale}")
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/errors/unknown_payment_action_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Errors
+      class UnknownPaymentActionError < StandardError
+        def initialize(_msg, locale)
+          super("Unknown payment action: #{locale}")
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/funding.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    class Funding
+      FORMAT_STRING = 'fundingList.fundingConstraint(%d).%s'
+      attr_reader :constraint
+
+      def constraint=(value)
+        raise "Unknown funding constraint: #{value}" unless PaysonAPI::V1::FUNDING_CONSTRAINTS.include?(value)
+
+        @constraint = value
+      end
+
+      def self.to_hash(fundings)
+        {}.tap do |hash|
+          fundings.each_with_index do |funding, index|
+            hash.merge!({
+                          format(FORMAT_STRING, index, 'constraint') => funding.constraint
+                        })
+          end
+        end
+      end
+
+      def self.parse(data)
+        [].tap do |fundings|
+          i = 0
+          while data[format(FORMAT_STRING, i, 'constraint')]
+            fundings << new.tap do |f|
+              f.constraint = data[format(FORMAT_STRING, i, 'constraint')]
+            end
+            i += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/order_item.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module PaysonAPI
+  module V1
+    class OrderItem
+      attr_accessor :description, :quantity, :unit_price, :sku, :tax
+
+      FORMAT_STRING = 'orderItemList.orderItem(%d).%s'
+
+      def self.to_hash(order_items)
+        {}.tap do |hash|
+          order_items.each_with_index do |item, index|
+            hash.merge!({
+                          format(FORMAT_STRING, index, 'description') => item.description,
+                          format(FORMAT_STRING, index, 'unitPrice') => item.unit_price,
+                          format(FORMAT_STRING, index, 'quantity') => item.quantity,
+                          format(FORMAT_STRING, index, 'taxPercentage') => item.tax,
+                          format(FORMAT_STRING, index, 'sku') => item.sku
+                        })
+          end
+        end
+      end
+
+      def self.parse(data)
+        [].tap do |order_items|
+          i = 0
+          while data[format(FORMAT_STRING, i, 'description')]
+            order_items << new.tap do |item|
+              item.description = CGI.unescape(data[format(FORMAT_STRING, i, 'description')].to_s)
+              item.unit_price = data[format(FORMAT_STRING, i, 'unitPrice')]
+              item.quantity = data[format(FORMAT_STRING, i, 'quantity')]
+              item.tax = data[format(FORMAT_STRING, i, 'taxPercentage')]
+              item.sku = data[format(FORMAT_STRING, i, 'sku')]
+            end
+            i += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/receiver.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module PaysonAPI
+  module V1
+    class Receiver
+      FORMAT_STRING = 'receiverList.receiver(%d).%s'
+      attr_accessor :email, :amount, :first_name, :last_name, :primary
+
+      def self.to_hash(receivers)
+        {}.tap do |hash|
+          receivers.each_with_index do |receiver, index|
+            raise 'Invalid receiver' unless receiver.instance_of?(self)
+
+            hash.merge!({
+                          format(FORMAT_STRING, index, 'email') => receiver.email,
+                          format(FORMAT_STRING, index, 'amount') => receiver.amount,
+                          format(FORMAT_STRING, index, 'firstName') => receiver.first_name,
+                          format(FORMAT_STRING, index, 'lastName') => receiver.last_name,
+                          format(FORMAT_STRING, index, 'primary') => receiver.primary
+                        })
+            hash[format(FORMAT_STRING, index, 'firstName')] = receiver.first_name if receiver.first_name
+            hash[format(FORMAT_STRING, index, 'lastName')] = receiver.last_name if receiver.last_name
+          end
+        end
+      end
+
+      def self.parse(data)
+        [].tap do |receivers|
+          i = 0
+          while data[format(FORMAT_STRING, i, 'email')]
+            receivers << new.tap do |r|
+              r.email = CGI.unescape(data[format(FORMAT_STRING, i, 'email')].to_s)
+              r.amount = data[format(FORMAT_STRING, i, 'amount')]
+              r.first_name = CGI.unescape(data[format(FORMAT_STRING, i, 'firstName')].to_s)
+              r.last_name = CGI.unescape(data[format(FORMAT_STRING, i, 'lastName')].to_s)
+              r.primary = data[format(FORMAT_STRING, i, 'primary')]
+            end
+            i += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/remote_error.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module PaysonAPI
+  module V1
+    class RemoteError
+      attr_accessor :id, :message, :parameter
+
+      FORMAT_STRING = 'errorList.error(%d).%s'
+
+      def initialize(id, message, parameter)
+        @id = id
+        @message = message
+        @parameter = parameter
+      end
+
+      def self.parse(data)
+        [].tap do |errors|
+          i = 0
+          while data[format(FORMAT_STRING, i, 'errorId')]
+            id = data[format(FORMAT_STRING, i, 'errorId')]
+            message = CGI.unescape(data[format(FORMAT_STRING, i, 'message')])
+            parameter = CGI.unescape(data[format(FORMAT_STRING, i, 'parameter')])
+            errors << new(id, message, parameter)
+            i += 1
+          end
+        end
+      end
+
+      def to_s
+        "ID: #{@id}, Message: #{@message}, Parameter: #{@parameter}"
+      end
+    end
+  end
+end

data/lib/payson_api/v1/requests/ipn.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Requests
+      class IPN
+        attr_accessor :data
+
+        def initialize(data)
+          @data = data
+        end
+
+        def to_s
+          @data
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/requests/payment.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Requests
+      class Payment
+        attr_accessor :return_url, :cancel_url, :ipn_url, :memo, :sender, :receivers,
+                      :locale, :currency, :tracking_id, :invoice_fee, :order_items, :fundings,
+                      :fees_payer, :guarantee_offered, :custom
+
+        def to_hash # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          {}.tap do |hash|
+            # Append mandatory params
+            hash['returnUrl'] = @return_url
+            hash['cancelUrl'] = @cancel_url
+            hash['memo'] = @memo
+            hash.merge!(@sender.to_hash)
+            hash.merge!(Receiver.to_hash(@receivers))
+
+            # Append optional params
+            append_locale(hash, @locale) if @locale
+            append_currency(hash, @currency) if @currency
+            append_fees_payer(hash, @fees_payer) if @fees_payer
+            append_guarantee(hash, @guarantee_offered) if @guarantee_offered
+            hash.merge!(OrderItem.to_hash(@order_items)) if @order_items
+            hash.merge!(Funding.to_hash(@fundings)) if @fundings
+            hash['ipnNotificationUrl'] = @ipn_url if @ipn_url
+            hash['invoiceFee'] = @invoice_fee if @invoice_fee
+            hash['trackingId'] = @tracking_id if @tracking_id
+            hash['custom'] = @custom if @custom
+          end
+        end
+
+        private
+
+        def append_locale(hash, locale)
+          raise PaysonAPI::V1::Errors::UnknownCurrencyError(locale) unless LOCALES.include?(locale)
+
+          hash['localeCode'] = locale
+        end
+
+        def append_currency(hash, currency)
+          unless PaysonAPI::V1::CURRENCIES.include?(currency)
+            raise PaysonAPI::V1::Errors::UnknownCurrencyError(currency)
+          end
+
+          hash['currencyCode'] = currency
+        end
+
+        def append_guarantee(hash, guarantee_offered)
+          unless PaysonAPI::V1::GUARANTEE_OFFERINGS.include?(guarantee_offered)
+            raise PaysonAPI::V1::Errors::UnknownGuaranteeOffering(guarantee_offered)
+          end
+
+          hash['guaranteeOffered'] = guarantee_offered
+        end
+
+        def append_fees_payer(hash, fees_payer)
+          unless PaysonAPI::V1::FEES_PAYERS.include?(fees_payer)
+            raise PaysonAPI::V1::Errors::UnknownFeesPayer(fees_payer)
+          end
+
+          hash['feesPayer'] = fees_payer
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/requests/payment_details.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Requests
+      class PaymentDetails
+        attr_accessor :token
+
+        def initialize(token)
+          @token = token
+        end
+
+        def to_hash
+          { 'token' => @token }
+        end
+      end
+    end
+  end
+end