active_merchant_every_pay 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b16416f31367ed866423531ebee7e250d3df2b2d39d72b97fd06b6d72fecbc9d
+  data.tar.gz: a051c3ce222fc4fc7f656b73896ff969d8d7269990074d51d88c9c770f3a976e
+SHA512:
+  metadata.gz: 3eb75bc2ecd845b3035e887eacaca40682a1b266e5fd9c6e771fdd7604a16bded54632d537699fa7f86d1e487efde73a007489680726f99b1fc290e901f29361
+  data.tar.gz: ce0d3f5e227d5ac20abcf0c681b78472ee10e54b2261bcadf712dd843276c2438482e3778f369f5592f6a6284946e0baec021e16b9aa7b69d49df3ebcf0d8500

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 1.0.0
+
+*   Initial version

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2017, CubeSystems <info@cubesystems.lv>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+EveryPay gateway for Active Merchant
+=============================================
+
+[![Build Status](https://travis-ci.org/cubesystems/active_merchant_every_pay.svg?branch=master)](https://travis-ci.org/cubesystems/active_merchant_every_pay)
+[![Coverage Status](https://coveralls.io/repos/github/cubesystems/active_merchant_every_pay/badge.svg?branch=master)](https://coveralls.io/github/cubesystems/active_merchant_every_pay?branch=master)
+
+## Install
+
+```bash
+$ gem install active_merchant_every_pay
+```
+
+## Usage
+
+```ruby
+require "active_merchant_every_pay"
+
+gateway = ActiveMerchant::Billing::EveryPayGateway.new(
+  api_username: "abc12345",
+  api_secret: "asdsasdsdasd",
+  account_name: "EUR1",
+  gateway_url: "https://igw-demo.every-pay.com/api/v3",
+  customer_url: "https://shop.example.com/cart"
+)
+
+# Authorize for 10 euros and 34 cents
+response = gateway.authorize(1034, order_reference: "order #123", email: "client@example.com", customer_ip: "127.0.0.1")
+
+# Use this url to redirect user to merchant portal
+response.authorization
+
+# Read status
+gateway.result(payment_reference: response.payment_reference)
+```
+
+### Gateways
+#### SEB
+test: `https://igw-demo.every-pay.com/api/v3`   
+production: `https://payment.ecommerce.sebgroup.com/api/v3`

data/lib/active_merchant/billing/every_pay_api_scheme.rb

@@ -0,0 +1,234 @@
+module ActiveMerchant
+  module Billing
+    class EveryPayApiScheme
+      REQUIRED_PARAM = :required
+      OPTIONAL_PARAM = :optional
+
+      TOKEN_AGREEMENT_RECURRING = 'recurring'
+      TOKEN_AGREEMENT_UNSCHEDULED = 'unscheduled'
+
+      POST_REQUEST = :post
+      GET_REQUEST = :get
+
+      PAYMENT_STATES = [
+        PAYMENT_STATE_INITIAL = "initial",
+        PAYMENT_STATE_SETTLED = "settled",
+        PAYMENT_STATE_VOIDED = "voided",
+        PAYMENT_STATE_FAILED = "failed",
+        PAYMENT_STATE_REFUNDED = "refunded",
+        PAYMENT_STATE_ABANDONED = "abandoned",
+        PAYMENT_STATE_AUTHORIZED = "authorized",
+        PAYMENT_STATE_CHARGEBACKED = "chargebacked",
+        PAYMENT_STATE_WAITING_FOR_3DS_RESPONSE = "waiting_for_3ds_response",
+        PAYMENT_STATE_WAITING_FOR_BAV = "waiting_for_bav"
+      ]
+
+      SCHEME = {
+        make_oneoff_payment: {
+          request: {
+            method: POST_REQUEST,
+            path: "/payments/oneoff",
+            params: {
+              api_username: REQUIRED_PARAM,
+              account_name: REQUIRED_PARAM,
+              amount: REQUIRED_PARAM,
+              customer_url: REQUIRED_PARAM,
+              token_agreement: OPTIONAL_PARAM,
+              mobile_payment: OPTIONAL_PARAM,
+              order_reference: OPTIONAL_PARAM,
+              nonce: REQUIRED_PARAM,
+              email: OPTIONAL_PARAM,
+              customer_ip: OPTIONAL_PARAM,
+              preferred_country: OPTIONAL_PARAM,
+              billing_city: OPTIONAL_PARAM,
+              billing_country: OPTIONAL_PARAM,
+              billing_line1: OPTIONAL_PARAM,
+              billing_line2: OPTIONAL_PARAM,
+              billing_line3: OPTIONAL_PARAM,
+              billing_postcode: OPTIONAL_PARAM,
+              billing_state: OPTIONAL_PARAM,
+              shipping_city: OPTIONAL_PARAM,
+              shipping_country: OPTIONAL_PARAM,
+              shipping_line1: OPTIONAL_PARAM,
+              shipping_line2: OPTIONAL_PARAM,
+              shipping_line3: OPTIONAL_PARAM,
+              shipping_code: OPTIONAL_PARAM,
+              shipping_state: OPTIONAL_PARAM,
+              locale: OPTIONAL_PARAM,
+              request_token: OPTIONAL_PARAM,
+              timestamp: REQUIRED_PARAM,
+              skin_name: OPTIONAL_PARAM,
+              integration_details: OPTIONAL_PARAM
+            }
+          },
+          response: {
+            successful_states: [PAYMENT_STATE_INITIAL]
+          }
+        },
+        make_mit_payment: {
+          request: {
+            method: POST_REQUEST,
+            path: "/payments/mit",
+            params: {
+              api_username: REQUIRED_PARAM,
+              account_name: REQUIRED_PARAM,
+              amount: REQUIRED_PARAM,
+              token_agreement: REQUIRED_PARAM,
+              merchant_ip: REQUIRED_PARAM,
+              order_reference: OPTIONAL_PARAM,
+              nonce: REQUIRED_PARAM,
+              email: OPTIONAL_PARAM,
+              timestamp: REQUIRED_PARAM,
+              token: REQUIRED_PARAM,
+              integration_details: OPTIONAL_PARAM
+            }
+          },
+          response: {
+            successful_states: [PAYMENT_STATE_SETTLED]
+          }
+        },
+        make_cit_payment: {
+          request: {
+            method: POST_REQUEST,
+            path: "/payments/cit",
+            params: {
+              api_username: REQUIRED_PARAM,
+              account_name: REQUIRED_PARAM,
+              amount: REQUIRED_PARAM,
+              token_agreement: OPTIONAL_PARAM,
+              order_reference: REQUIRED_PARAM,
+              nonce: REQUIRED_PARAM,
+              email: OPTIONAL_PARAM,
+              customer_ip: OPTIONAL_PARAM,
+              customer_url: REQUIRED_PARAM,
+              timestamp: REQUIRED_PARAM,
+              token: REQUIRED_PARAM,
+              billing_city: OPTIONAL_PARAM,
+              billing_country: OPTIONAL_PARAM,
+              billing_line1: OPTIONAL_PARAM,
+              billing_line2: OPTIONAL_PARAM,
+              billing_line3: OPTIONAL_PARAM,
+              billing_postcode: OPTIONAL_PARAM,
+              billing_state: OPTIONAL_PARAM,
+              integration_details: OPTIONAL_PARAM
+            }
+          },
+          response: {
+            successful_states: [PAYMENT_STATE_WAITING_FOR_3DS_RESPONSE]
+          }
+        },
+        capture_payment: {
+          request: {
+            method: POST_REQUEST,
+            path: "/payments/capture",
+            params: {
+              api_username: REQUIRED_PARAM,
+              amount: REQUIRED_PARAM,
+              payment_reference: REQUIRED_PARAM,
+              nonce: REQUIRED_PARAM,
+              timestamp: REQUIRED_PARAM,
+            }
+          },
+          response: {
+            successful_states: [PAYMENT_STATE_SETTLED]
+          }
+        },
+        refund_payment: {
+          request: {
+            method: POST_REQUEST,
+            path: "/payments/refund",
+            params: {
+              api_username: REQUIRED_PARAM,
+              amount: REQUIRED_PARAM,
+              payment_reference: REQUIRED_PARAM,
+              nonce: REQUIRED_PARAM,
+              timestamp: REQUIRED_PARAM,
+            }
+          },
+          response: {
+            successful_states: [PAYMENT_STATE_REFUNDED]
+          }
+        },
+        void_payment: {
+          request: {
+            method: POST_REQUEST,
+            path: "/payments/void",
+            params: {
+              api_username: REQUIRED_PARAM,
+              payment_reference: REQUIRED_PARAM,
+              nonce: REQUIRED_PARAM,
+              timestamp: REQUIRED_PARAM,
+              reason: REQUIRED_PARAM,
+            }
+          },
+          response: {
+            successful_states: [PAYMENT_STATE_VOIDED]
+          }
+        },
+        payment_reference: {
+          request: {
+            method: GET_REQUEST,
+            path: "/payments/:payment_reference",
+            params: {
+              api_username: REQUIRED_PARAM,
+              payment_reference: REQUIRED_PARAM
+            }
+          },
+          response: {
+            successful_states: [PAYMENT_STATE_SETTLED]
+          }
+        },
+      }
+
+      def self.for api_call
+        new(api_call)
+      end
+
+      def initialize api_call
+        @api_call = api_call
+        @scheme = SCHEME.fetch(api_call)
+      end
+
+      def successful_response? json_response
+        successful_response_states = @scheme.fetch(:response, {}).fetch(:successful_states, [])
+
+        successful_response_states.empty? || successful_response_states.include?(json_response["payment_state"])
+      end
+
+      def validate_params params
+        mandatory_params = request_params.map{|key, type| key if type == REQUIRED_PARAM }.compact
+        all_params = request_params.keys
+
+        missing_params = mandatory_params - params.keys
+        raise ArgumentError, "Missing request params: #{missing_params}" if missing_params.any?
+
+        unknown_params = params.keys - request_params.keys
+        raise ArgumentError, "Unknown request params: #{unknown_params}" if unknown_params.any?
+      end
+
+      def name
+        @api_call
+      end
+
+      def request_params
+         @scheme.fetch(:request).fetch(:params, {})
+      end
+
+      def request_method
+        @scheme.fetch(:request).fetch(:method)
+      end
+
+      def post_request?
+        request_method == POST_REQUEST
+      end
+
+      def get_request?
+        request_method == GET_REQUEST
+      end
+
+      def request_path
+        @scheme.fetch(:request).fetch(:path)
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/every_pay_gateway.rb

@@ -0,0 +1,138 @@
+module ActiveMerchant
+  module Billing
+    class EveryPayGateway < Gateway
+
+      TEST_GATEWAY_URL = "https://igw-demo.every-pay.com/api/v3"
+
+      self.display_name = "EveryPay"
+      self.money_format = :dollars
+
+      def initialize(options = {})
+        options[:gateway_url] = TEST_GATEWAY_URL if ActiveMerchant::Billing::Base.test?
+
+        required_options = [:api_username, :api_secret, :account_name, :gateway_url, :customer_url]
+
+        requires!(options, *required_options)
+        @options = options
+        super
+      end
+
+      def authorize(money, params = {})
+        params = params.merge(
+          api_username: @options[:api_username],
+          account_name: @options[:account_name],
+          customer_url: @options[:customer_url],
+          amount: amount(money),
+          nonce: nonce,
+          timestamp: timestamp
+        )
+
+        commit(:make_oneoff_payment, params)
+      end
+
+      def recurring_merchant(money, params = {})
+        params = params.merge(
+          api_username: @options[:api_username],
+          account_name: @options[:account_name],
+          amount: amount(money),
+          nonce: nonce,
+          timestamp: timestamp
+        )
+
+        commit(:make_mit_payment, params)
+      end
+
+      def recurring_customer(money, params = {})
+        params = params.merge(
+          api_username: @options[:api_username],
+          account_name: @options[:account_name],
+          amount: amount(money),
+          nonce: nonce,
+          timestamp: timestamp
+        )
+
+        commit(:make_cit_payment, params)
+      end
+
+      def capture(money, params = {})
+        params = params.merge(
+          api_username: @options[:api_username],
+          amount: amount(money),
+          nonce: nonce,
+          timestamp: timestamp
+        )
+
+        commit(:capture_payment, params)
+      end
+
+      def refund(money, params = {})
+        params = params.merge(
+          api_username: @options[:api_username],
+          amount: amount(money),
+          nonce: nonce,
+          timestamp: timestamp
+        )
+
+        commit(:refund_payment, params)
+      end
+
+      def void(params = {})
+        params = params.merge(
+          api_username: @options[:api_username],
+          nonce: nonce,
+          timestamp: timestamp
+        )
+
+        commit(:void_payment, params)
+      end
+
+      def result(params = {})
+        params = params.merge(
+          api_username: @options[:api_username],
+        )
+
+        commit(:payment_reference, params)
+      end
+
+      def timestamp
+        DateTime.now.iso8601
+      end
+
+      def nonce
+        Random.new_seed
+      end
+
+      def commit(api_call, params)
+        raw_response = nil
+        response = nil
+
+        scheme = EveryPayApiScheme.for(api_call)
+        scheme.validate_params(params)
+
+        request = EveryPayRequest.new(@options, scheme, params)
+        response = raw_ssl_request(request.method, request.url, request.data, request.headers)
+        json_response = parse(response, scheme)
+
+        EveryPayResponse.new(json_response)
+      end
+
+      def parse(response, scheme)
+        begin
+          json_response = JSON.parse(response.body)
+
+          if json_response["error"].nil? && !scheme.successful_response?(json_response)
+            json_response["error"] = {"message" => "Unsuccessful response for :#{scheme.name} API call"}
+          end
+        rescue JSON::ParserError
+          json_response = {
+            "error" => {
+              "message" => "Non parsable response received from the EveryPay API, status code: #{response.code}, body: #{response.body}"
+            }
+          }
+        end
+
+        json_response
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/every_pay_request.rb

@@ -0,0 +1,42 @@
+module ActiveMerchant
+  module Billing
+    class EveryPayRequest
+      attr_accessor :gateway_options, :scheme, :params
+
+      def initialize gateway_options, scheme, params
+        self.gateway_options = gateway_options
+        self.scheme = scheme
+        self.params = params
+      end
+
+      def data
+        params.to_json if scheme.post_request?
+      end
+
+      def url
+        uri = URI(gateway_options.fetch(:gateway_url))
+        uri.path += scheme.request_path.gsub(/(:[\w]*)/) {|m| m.gsub(m, params.fetch(m.tr(":", "").to_sym)) }
+
+        uri.query = URI.encode_www_form(params) if scheme.get_request?
+
+        uri.to_s
+      end
+
+      def method
+        scheme.request_method
+      end
+
+      def headers
+        {
+          "Content-Type" => "application/json",
+          "Accept" => "application/json",
+          "Authorization" => basic_auth
+        }
+      end
+
+      def basic_auth
+        "Basic " + Base64.strict_encode64("#{gateway_options.fetch(:api_username)}:#{gateway_options.fetch(:api_secret)}")
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/every_pay_response.rb

@@ -0,0 +1,27 @@
+module ActiveMerchant
+  module Billing
+    class EveryPayResponse < Response
+      def initialize json_response
+        success = json_response["error"].nil?
+
+        super success,
+          success ? 'SUCCESS' : json_response["error"]["message"],
+          json_response,
+          test: test?,
+          authorization: json_response["payment_link"]
+      end
+
+      def payment_state
+        params["payment_state"]
+      end
+
+      def payment_reference
+        params["payment_reference"]
+      end
+
+      def error
+        params["error"]
+      end
+    end
+  end
+end

data/lib/active_merchant_every_pay.rb

@@ -0,0 +1,5 @@
+require "active_merchant"
+require "active_merchant/billing/every_pay_api_scheme"
+require "active_merchant/billing/every_pay_request"
+require "active_merchant/billing/every_pay_response"
+require "active_merchant/billing/every_pay_gateway"

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: active_merchant_every_pay
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- CubeSystems
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemerchant
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.15.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.15.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.23
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.23
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+description: EveryPay gateway for Active Merchant
+email:
+- info@cubesystems.lv
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/active_merchant/billing/every_pay_api_scheme.rb
+- lib/active_merchant/billing/every_pay_gateway.rb
+- lib/active_merchant/billing/every_pay_request.rb
+- lib/active_merchant/billing/every_pay_response.rb
+- lib/active_merchant_every_pay.rb
+homepage: https://github.com/cubesystems/active_merchant_every_pay
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.2
+signing_key:
+specification_version: 4
+summary: EveryPay gateway for Active Merchant
+test_files: []