payson_api 0.3.3 → 1.0.2

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

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Responses
+      class Payment
+        attr_accessor :envelope, :token, :errors
+
+        def initialize(data)
+          @envelope = PaysonAPI::V1::Envelope.parse(data)
+          @token = data['TOKEN']
+          @errors = PaysonAPI::V1::RemoteError.parse(data)
+        end
+
+        def success?
+          @envelope.ack == 'SUCCESS'
+        end
+
+        def forward_url
+          PaysonAPI::V1.forward_url(@token)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module PaysonAPI
+  module V1
+    module Responses
+      class PaymentDetails
+        attr_accessor :envelope, :purchase_id, :sender_email, :status,
+                      :payment_type, :guarantee_status, :guarantee_deadline_at,
+                      :invoice_status, :custom, :tracking_id, :receivers, :currency,
+                      :order_items, :errors, :fundings, :token, :shipping_address
+
+        def initialize(data)
+          @envelope = PaysonAPI::V1::Envelope.parse(data)
+          @purchase_id = data['purchaseId']
+          @payment_type = data['type']
+          @comment = data['custom']
+          @tracking_id = data['trackingId']
+          @currency = data['currencyCode']
+          @sender_email = data['senderEmail']
+          @status = data['status']
+          @token = data['token']
+          @fundings = PaysonAPI::V1::Funding.parse(data)
+          @receivers = PaysonAPI::V1::Receiver.parse(data)
+          @order_items = PaysonAPI::V1::OrderItem.parse(data)
+          @errors = PaysonAPI::V1::RemoteError.parse(data)
+          append_payment_type_conditionals
+        end
+
+        def append_payment_type_conditionals
+          case @payment_type
+          when 'GUARANTEE'
+            @guarantee_status = data['guaranteeStatus']
+            @guarantee_deadline_at = Time.parse(CGI.unescape(data['guaranteeDeadlineTimestamp']))
+          when 'INVOICE'
+            @invoice_status = data['invoiceStatus']
+            if %w[ORDERCREATED SHIPPED DONE CREDITED].include?(@invoice_status)
+              @shipping_address = PaysonAPI::V1::ShippingAddress.parse(data)
+            end
+          end
+        end
+
+        def success?
+          @envelope.ack == 'SUCCESS'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Responses
+      class PaymentUpdate
+        attr_accessor :envelope, :errors
+
+        def initialize(data)
+          @envelope = PaysonAPI::V1::Envelope.parse(data)
+          @errors = PaysonAPI::V1::RemoteError.parse(data)
+        end
+
+        def success?
+          @envelope.ack == 'SUCCESS'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V1
+    module Responses
+      class Validate
+        attr_accessor :data
+
+        def initialize(data)
+          @data = data
+        end
+
+        def verified?
+          @data == 'VERIFIED'
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/sender.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module PaysonAPI
+  module V1
+    class Sender
+      FORMAT_STRING = 'sender%s'
+      attr_accessor :email, :first_name, :last_name
+
+      def to_hash
+        {}.tap do |hash|
+          hash[FORMAT_STRING % 'Email'] = @email
+          hash[FORMAT_STRING % 'FirstName'] = @first_name
+          hash[FORMAT_STRING % 'LastName'] = @last_name
+        end
+      end
+
+      def self.parse(data)
+        new.tap do |s|
+          s.email = data[FORMAT_STRING % 'email']
+          s.first_name = CGI.unescape(data[FORMAT_STRING % 'FirstName'].to_s)
+          s.last_name = CGI.unescape(data[FORMAT_STRING % 'LastName'].to_s)
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v1/shipping_address.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module PaysonAPI
+  module V1
+    class ShippingAddress
+      FORMAT_STRING = 'shippingAddress.%s'
+      attr_accessor :name, :street_address, :postal_code, :city, :country
+
+      def to_hash
+        {}.tap do |hash|
+          hash[FORMAT_STRING % 'name'] = @name
+          hash[FORMAT_STRING % 'streetAddress'] = @street_address
+          hash[FORMAT_STRING % 'postalCode'] = @postal_code
+          hash[FORMAT_STRING % 'city'] = @city
+          hash[FORMAT_STRING % 'country'] = @country
+        end
+      end
+
+      def self.parse(data)
+        return unless data[FORMAT_STRING % 'name']
+
+        new.tap do |s|
+          s.name = CGI.unescape(data[FORMAT_STRING % 'name'].to_s)
+          s.street_address = CGI.unescape(data[FORMAT_STRING % 'streetAddress'].to_s)
+          s.postal_code = CGI.unescape(data[FORMAT_STRING % 'postalCode'].to_s)
+          s.city = CGI.unescape(data[FORMAT_STRING % 'city'].to_s)
+          s.country = CGI.unescape(data[FORMAT_STRING % 'country'].to_s)
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v2/client.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'net/https'
+require 'json'
+
+module PaysonAPI
+  module V2
+    class Client
+      def self.account_info
+        response = payson_request(Net::HTTP::Get, PAYSON_API_RESOURCES[:accounts][:get])
+        PaysonAPI::V2::Models::Account.from_hash(JSON.parse(response.body))
+      end
+
+      def self.get_checkout(id)
+        response = payson_request(Net::HTTP::Get, PAYSON_API_RESOURCES[:checkouts][:get] % id)
+        PaysonAPI::V2::Models::Checkout.from_hash(JSON.parse(response.body))
+      end
+
+      def self.create_checkout(request)
+        response = payson_request(Net::HTTP::Post, PAYSON_API_RESOURCES[:checkouts][:create], request)
+        intercept_validation_errors(response)
+        PaysonAPI::V2::Models::Checkout.from_hash(JSON.parse(response.body))
+      end
+
+      def self.update_checkout(request)
+        response = payson_request(Net::HTTP::Put, PAYSON_API_RESOURCES[:checkouts][:update] % request.id, request)
+        intercept_validation_errors(response)
+        PaysonAPI::V2::Models::Checkout.from_hash(JSON.parse(response.body))
+      end
+
+      def self.list_checkouts(request)
+        path = [PAYSON_API_RESOURCES[:checkouts][:list], hash_to_params(request.to_hash)].join('?')
+        response = payson_request(Net::HTTP::Get, path)
+        [].tap do |checkouts|
+          JSON.parse(response.body)['data'].each do |json|
+            checkouts << PaysonAPI::V2::Models::Checkout.from_hash(json)
+          end
+        end
+      end
+
+      def self.intercept_validation_errors(response)
+        if response.code == '400' || response.code == '500' # rubocop:disable Style/GuardClause
+          raise PaysonAPI::V2::Errors::ValidationError, errors: JSON.parse(response.body)['errors']
+        end
+      end
+
+      def self.hash_to_params(hash)
+        hash.map { |k, v| "#{k}=#{URI.encode_www_form_component(v.to_s)}" }.join('&')
+      end
+
+      def self.payson_request(method, resource, request = nil)
+        url = [PaysonAPI::V2.api_base_url, PAYSON_API_VERSION, resource].join('/')
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        req = method.new(uri.request_uri)
+        req.basic_auth PaysonAPI::V2.config.api_user_id, PaysonAPI::V2.config.api_password
+        req.body = JSON.generate(request.to_hash) unless request.nil?
+        req['Content-Type'] = 'application/json'
+        response = http.request(req)
+        raise PaysonAPI::V2::Errors::UnauthorizedError if response.code == '401'
+
+        response
+      end
+
+      private_class_method :intercept_validation_errors, :hash_to_params, :payson_request
+    end
+  end
+end

data/lib/payson_api/v2/config.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V2
+    module_function
+
+    PAYSON_API_ENDPOINT = 'https://%s.payson.se'
+    PAYSON_API_VERSION = '2.0'
+    PAYSON_API_RESOURCES = {
+      checkouts: {
+        create: 'Checkouts',
+        update: 'Checkouts/%s',
+        get: 'Checkouts/%s',
+        list: 'Checkouts'
+      },
+      accounts: {
+        get: 'Accounts'
+      }
+    }.freeze
+
+    PAYSON_API_TEST_ENDPOINT = 'https://test-api.payson.se'
+
+    LOCALES = %w[SV EN FI].freeze
+    CURRENCIES = %w[sek eur].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
+  end
+end

data/lib/payson_api/v2/errors/unauthorized_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V2
+    module Errors
+      class UnauthorizedError < StandardError
+      end
+    end
+  end
+end

data/lib/payson_api/v2/errors/validation_error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V2
+    module Errors
+      class ValidationError < StandardError
+        attr_reader :errors
+
+        def initialize(msg = 'Validation failed', errors: [])
+          @errors = errors
+          super(msg)
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v2/models/account.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V2
+    module Models
+      class Account
+        attr_accessor :account_email, :status, :merchant_id, :enabled_for_invoice,
+                      :enabled_for_payment_plan, :enabled_for_recurring_payments
+
+        def self.from_hash(hash)
+          new.tap do |account|
+            account.account_email = hash['accountEmail']
+            account.status = hash['status']
+            account.merchant_id = hash['merchantId']
+            account.enabled_for_invoice = hash['enabledForInvoice']
+            account.enabled_for_payment_plan = hash['enabledForpaymentPlan']
+            account.enabled_for_recurring_payments = hash['enabledForRecurringPayments']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/payson_api/v2/models/checkout.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module PaysonAPI
+  module V2
+    module Models
+      class Checkout
+        attr_accessor :id, :status, :expiration_time, :description, :snippet,
+                      :customer, :order, :merchant
+
+        def self.from_hash(hash)
+          new.tap do |checkout|
+            checkout.id = hash['id']
+            checkout.status = hash['status']
+            checkout.expiration_time = hash['expirationTime']
+            checkout.description = hash['description']
+            checkout.snippet = hash['snippet']
+
+            checkout.customer = PaysonAPI::V2::Models::Customer.from_hash(hash['customer']) if hash['customer']
+
+            checkout.merchant = PaysonAPI::V2::Models::Merchant.from_hash(hash['merchant']) if hash['merchant']
+
+            checkout.order = PaysonAPI::V2::Models::Order.from_hash(hash['order'])
+          end
+        end
+      end
+    end
+  end
+end