payson_api 0.3.2 → 1.0.1

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

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Requests
+      class PaymentUpdate
+        attr_accessor :token, :action
+
+        def initialize(token, action)
+          unless PaysonAPI::V1::PAYMENT_ACTIONS.include?(action)
+            raise PaysonAPI::V1::Errors::UnknownPaymentActionError(action)
+          end
+
+          @token = token
+          @action = action
+        end
+
+        def to_hash
+          {}.tap do |hash|
+            hash['token'] = @token
+            hash['action'] = @action
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Responses
+      class IPN
+        attr_accessor :purchase_id, :sender_email, :status,
+                      :payment_type, :guarantee_status, :guarantee_deadline_at,
+                      :invoice_status, :custom, :tracking_id, :receivers, :currency,
+                      :order_items, :fundings, :token, :shipping_address, :raw, :hash
+
+        def initialize(raw_data)
+          @raw = raw_data
+          data_hash = PaysonAPI::V1::Client.params_to_hash(raw_data)
+          @purchase_id = data_hash['purchaseId']
+          @payment_type = data_hash['type']
+          @comment = data_hash['custom']
+          @tracking_id = data_hash['trackingId']
+          @currency = data_hash['currencyCode']
+          @sender_email = data_hash['senderEmail']
+          @status = data_hash['status']
+          @token = data_hash['token']
+          @fundings = PaysonAPI::V1::Funding.parse(data_hash)
+          @receivers = PaysonAPI::V1::Receiver.parse(data_hash)
+          @order_items = PaysonAPI::V1::OrderItem.parse(data_hash)
+          @hash = data_hash['HASH']
+          append_payment_type_conditionals
+        end
+
+        def append_payment_type_conditionals
+          case @payment_type
+          when 'GUARANTEE'
+            @guarantee_status = data_hash['guaranteeStatus']
+            @guarantee_deadline_at = Time.parse(data_hash['guaranteeDeadlineTimestamp'])
+          when 'INVOICE'
+            @invoice_status = data_hash['invoiceStatus']
+            @shipping_address = PaysonAPI::V1::ShippingAddress.parse(data_hash)
+          end
+        end
+      end
+    end
+  end
+end