activemerchant-payrix 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b5f27c2329b7dd97eea8fa718529e9cfe446496aec74279f3ded59b760a70d0c
+  data.tar.gz: e18c98fc51a9e46d4da61555ae51913e2c402a9ab17e5f1175d3129aecfa6c34
+SHA512:
+  metadata.gz: aae551c3f73eac29a2537d8bbfc5dd4e78cf79fea954a699de6ad3b6364d95b5e34cd78f38e67e398ce95a4e336fb10ce8fc19095089d2bb85ab38b34c231be6
+  data.tar.gz: 8da97305ef6a13caa2844619446eee91016389ad40b655db10568495b7e05f5fb1f7408bfad0c6cbca718874a5413cdf0ff1af95c3562d21e0bc80424607b64f

data/.github/workflows/release.yml

@@ -0,0 +1,24 @@
+on:
+  push:
+    branches: [main]
+
+jobs:
+  push:
+    name: Push gem to RubyGems.org
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write # IMPORTANT: this permission is mandatory for trusted publishing
+      contents: write # IMPORTANT: this permission is required for `rake release` to push the release tag
+
+    steps:
+      # Set up
+      - uses: actions/checkout@v4
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+          ruby-version: ruby
+
+      # Release
+      - uses: rubygems/release-gem@v1

data/.github/workflows/run-tests.yml

@@ -0,0 +1,20 @@
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@359bebbc29cbe6c87da6bc9ea3bc930432750108
+        with:
+          ruby-version: '3.1'
+      - name: Install dependencies
+        run: bundle install
+      - name: Run tests
+        run: bundle exec rake test:units

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+spec/test_credentials.rb
+.vscode

data/.rvmrc

@@ -0,0 +1 @@
+rvm use @activemerchant-payrix --create

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2022 Mark Haussmann
+
+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/Rakefile

@@ -0,0 +1,40 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'activemerchant/payrix/version'
+
+begin
+  require 'bundler'
+  Bundler.setup
+rescue LoadError => e
+  puts "Error loading bundler (#{e.message}): \"gem install bundler\" for bundler support."
+  require 'rubygems'
+end
+
+require 'rake'
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+task :tag_release do
+  system "git tag 'v#{ActiveMerchant::Payrix::VERSION}'"
+  system 'git push --tags'
+end
+
+desc 'Run the unit test suite'
+task default: 'test:units'
+task test: 'test:units'
+
+namespace :test do
+  Rake::TestTask.new(:units) do |t|
+    t.pattern = 'test/unit/**/*_test.rb'
+    t.libs << 'test'
+    t.verbose = false
+  end
+
+  desc 'Run all tests that do not require network access'
+  task local: %w[test:units]
+
+  Rake::TestTask.new(:remote) do |t|
+    t.pattern = 'test/remote/**/*_test.rb'
+    t.libs << 'test'
+    t.verbose = true
+  end
+end

data/Readme.md

@@ -0,0 +1,52 @@
+# activemerchant-payrix
+
+ActiveMerchant Payrix is an add-on for ActiveMerchant which provides a gateway
+for [Payrix's](https://www.payrix.com/)
+[HPP service](https://docs.rest.paymentsapi.io/#5bd000e6-e156-4242-962b-3b93e9ed8f9e).
+
+## Installation
+
+Before installing the gem you should have a Payrix account ready to use. If not
+then [Contact Payrix for more info.](https://www.payrix.com/)
+
+To install simply add the following line to your `Gemfile` and then run
+`bundle install`:
+
+```ruby
+gem 'activemerchant-payrix'
+```
+
+The gateway can be initialised by passing your login details like so:
+
+```ruby
+gateway = ActiveMerchant::Billing::PayrixGateway.new(:login => 'login', :password => 'pass', :business_id => 'num', :service => 'hpp')
+```
+
+## Usage
+
+Once you have an initialised gateway, you can use the `setup_purchase` method:
+
+```ruby
+amount     = 1000 # 1000 cents is $10.00 AUD
+options    = { return_url: return_url } # Pass the return url to Payrix
+
+response = gateway.purchase(amount, options)
+
+if response.sucess?
+  puts "All OK!"
+else
+  puts response.message # Output the error message
+end
+```
+
+## License
+
+activemerchant-payrix is distributed under a standard MIT license, see
+[LICENSE](https://github.com/mhssmnn/activemerchant-payrix/blob/master/LICENSE)
+for further information.
+
+## Contributing
+
+Fork on GitHub and after you’ve committed tested patches, send a pull request.
+
+To get tests running simply run `bundle install` and then `rake test:units`.

data/activemerchant-payrix.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'activemerchant/payrix/version'
+
+Gem::Specification.new do |s|
+  s.name = 'activemerchant-payrix'
+  s.version = ActiveMerchant::Payrix::VERSION
+  s.authors = ['Mark Haussmann']
+  s.email = ['mark.haussmann@gmail.com']
+  s.homepage = ''
+  s.summary = 'ActiveMerchant Payrix Plugin'
+  s.description = 'An ActiveMerchant plugin that provides a Payrix gateway'
+
+  s.rubyforge_project = 'activemerchant-payrix'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables =
+    `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_development_dependency('test-unit', '~> 3')
+  s.add_development_dependency('mocha', '~> 2')
+  s.add_development_dependency('rake')
+  s.add_runtime_dependency 'activemerchant', '>= 1.20.0'
+end

data/lib/activemerchant/billing/gateways/payrix.rb

@@ -0,0 +1,396 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayrixGateway < Gateway
+      self.test_url = 'https://sandbox.rest.paymentsapi.io'
+      self.live_url = 'https://rest.paymentsapi.io'
+
+      class_attribute :test_auth_url
+      self.test_auth_url = 'https://sandbox.auth.paymentsapi.io/login'
+
+      class_attribute :auth_url
+      self.auth_url = 'https://auth.paymentsapi.io/login'
+
+      self.supported_countries = %w[US AU NZ]
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover]
+      self.money_format = :dollars
+
+      self.homepage_url = 'https://www.payrix.com/'
+      self.display_name = 'Payrix'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        'EXPIRED' => STANDARD_ERROR_CODE[:expired_card],
+        'FRAUD_CHECK_DECLINE' => STANDARD_ERROR_CODE[:invalid_cvc],
+        'FRAUD_CHECK_ERROR' => STANDARD_ERROR_CODE[:processing_error],
+        'ERROR' => STANDARD_ERROR_CODE[:processing_error],
+        'BadRequest' => STANDARD_ERROR_CODE[:processing_error],
+        'FunctionNotAllowed' => STANDARD_ERROR_CODE[:unsupported_feature],
+        'InternalServerError' => STANDARD_ERROR_CODE[:processing_error],
+        'InvalidApiToken' => STANDARD_ERROR_CODE[:config_error]
+      }
+
+      TRANSACTION_TYPES = {
+        # Full sale - Funds are fully collected and ready to be settled to your business
+        purchase: 'COMPLETE',
+        # Pre-authorisation only - Funds are reserved on the person's card and will not be collected until you use the Capture function. Pre-auths that aren't captured automatically expire (usually occurs within 2-3 days)
+        authorize: 'PREAUTH',
+        # This allows you to perform a zero-dollar pre-authorisation for the purpose of checking that a particular card is valid and active.
+        # It also assists in meeting card-on-file storage obligations, and customer-initiated-transaction/merchant-initiated-transaction mandates, by allowing you to verify a card using customer authentication before storage, and obtain a reference that can be provided with future recurring transactions on that card to link them to the initial authorisation.
+        verify: 'VERIFY'
+      }
+
+      ENDPOINTS = {
+        hpp: 'hpp/',
+        eddr: 'eddr/',
+        vault: 'vault/',
+        access_token: 'login'
+      }
+
+      TOKEN_STATUS = {
+        waiting: 'WAITING',
+        validated: 'VALIDATED',
+        processed_successful: 'PROCESSED_SUCCESSFUL',
+        processed_rejected: 'PROCESSED_REJECTED',
+        cancelled: 'CANCELLED',
+        error: 'ERROR',
+        fraud_check_decline: 'FRAUD_CHECK_DECLINE',
+        fraud_check_error: 'FRAUD_CHECK_ERROR',
+        expired: 'EXPIRED'
+      }
+
+      TOKEN_STATUS_DESCRIPTIONS = {
+        'WAITING' => 'Token URL not yet accessed',
+        'VALIDATED' => 'Token URL loaded',
+        'PROCESSED_SUCCESSFUL' => 'URL completed successfully',
+        'PROCESSED_REJECTED' => 'URL Opened, not completed and closed',
+        'CANCELLED' => 'URL Completed but cancelled on confirmation page',
+        'ERROR' => 'Internal error received',
+        'FRAUD_CHECK_DECLINE' =>
+          'Payment attempted but declined by Fraud check',
+        'FRAUD_CHECK_ERROR' =>
+          'Payment attempted but Fraud Check error received',
+        'EXPIRED' => 'Token has expired and is no longer useable'
+      }
+
+      TRANSACTION_STATUS = { cleared: 'C', settled: 'S', rejected: 'R' }
+
+      REJECTION_REASONS = {
+        'R1' => 'Insufficient funds',
+        'R2' => 'Invalid bank account number',
+        'R3' => 'Invalid credit card',
+        'R4' => 'Expired credit card',
+        'R5' => 'Invalid transaction',
+        'R6' => 'Transaction declined',
+        'R7' => 'Authority revoked by payer',
+        'R8' => 'Payer deceased',
+        'R9' => 'Invalid bank account',
+        'R10' => 'Bank account closed',
+        'R11' => 'Invalid payer contact details',
+        'R12' => 'Direct debit claim',
+        'R13' => 'Credit card chargeback',
+        'R14' => 'Stolen/pick up card',
+        'R15' => 'Limits exceeded',
+        'R16' => 'Pre-auth expired',
+        'R17' => 'Not processed (payer inactive)',
+        'R18' => 'Fraud protection triggered',
+        'R19' => 'Voided',
+        'R20' => 'Fraud Check / 3-D Secure: Authentication Failed',
+        'R21' => 'Fraud Check / 3-D Secure: Unable to Authenticate',
+        'R22' => 'Fraud Check / 3-D Secure: Transaction Abandoned',
+        'R23' => 'Fraud Check / 3-D Secure: Error Occurred',
+        'RF' => 'Partially refunded',
+        'UR' => 'Under review'
+      }
+
+      def initialize(options = {})
+        requires!(options, :login, :password, :business_id)
+
+        @business_id = options[:business_id]
+        @service = (options[:service]&.to_sym || :hpp)
+        @token = nil
+
+        unless ENDPOINTS.key?(@service)
+          raise ArgumentError, "Unsupported service `#{@service}'."
+        end
+
+        super
+      end
+
+      def setup_purchase(money, options = {})
+        requires!(options, :return_url, :transaction_reference)
+        requires!(options, :unique_reference, :name) if store?
+
+        post = new_post
+
+        add_transaction(post, money, options)
+        add_customer_data(post, options)
+        add_address(post, options)
+        add_template(post, options)
+        add_audit(post, options)
+        add_return_url(post, options)
+
+        MultiResponse.run do |r|
+          r.process { commit :access_token, create_access_token_request }
+          r.process { commit :purchase, post, access_token: access_token(r) }
+        end.primary_response
+      end
+
+      def setup_authorize(money, options = {})
+        requires!(options, :return_url, :transaction_reference)
+        requires!(options, :unique_reference, :name) if store?
+
+        post = new_post
+
+        add_transaction(post, money, options)
+        add_customer_data(post, options)
+        add_address(post, options)
+        add_template(post, options)
+        add_audit(post, options)
+        add_return_url(post, options)
+
+        MultiResponse.run do |r|
+          r.process { commit :access_token, create_access_token_request }
+          r.process { commit :authorize, post, access_token: access_token(r) }
+        end.primary_response
+      end
+
+      def setup_verify(options = {})
+        requires!(options, :return_url, :transaction_reference)
+        requires!(options, :unique_reference, :name) if store?
+
+        post = new_post
+
+        # add_transaction(post, money, options)
+        add_customer_data(post, options)
+        add_address(post, options)
+        add_template(post, options)
+        add_audit(post, options)
+        add_return_url(post, options)
+
+        MultiResponse.run do |r|
+          r.process { commit :access_token, create_access_token_request }
+          r.process { commit :verify, post, access_token: access_token(r) }
+        end.primary_response
+      end
+
+      # Swap token for details about success / failure of transaction
+      def details_for(token_id)
+        payload = { id: token_id }
+
+        MultiResponse.run do |r|
+          r.process { commit :access_token, create_access_token_request }
+          r.process { commit :token, payload, access_token: access_token(r) }
+        end.primary_response
+      end
+
+      private
+
+      def new_post
+        { payer: {}, transaction: {} }
+      end
+
+      def add_transaction(post, money, options)
+        t = post[:transaction]
+
+        t[:reference] = trim(options[:transaction_reference])
+        t[:description] = options[:description] || ''
+        t[:amount] = amount(money)
+        t[:currency_code] = (options[:currency] || currency(money))
+
+        post[:transaction] = t
+      end
+
+      def add_customer_data(post, options)
+        payer = post[:payer]
+
+        payer[:save_payer] = (options[:store] || false)
+        payer[:unique_reference] = trim(options[:customer_reference]) if store?
+        payer[:group_reference] = trim(options[:group_reference]) if store?
+        payer[:family_or_business_name] = options[:name] if store?
+        payer[:email] = options[:email]
+        payer[:phone] = options[:phone]
+        payer[:mobile] = options[:mobile]
+        payer[:date_of_birth] = options[:date_of_birth]
+
+        post[:payer] = payer
+      end
+
+      def add_address(post, options)
+        if (address = (options[:billing_address] || options[:address]))
+          post[:payer].tap do |h|
+            h[:address] = {}
+            h[:address][:line1] = address[:address1] if address[:address1]
+            h[:address][:line2] = address[:address2] if address[:address2]
+            h[:address][:state] = address[:state] if address[:state]
+            h[:address][:country] = address[:country] if address[:country]
+            h[:address][:post_code] = address[:zip] if address[:zip]
+          end
+        end
+      end
+
+      def add_template(post, options)
+        post[:template] = (options[:template] || 'Basic')
+      end
+
+      def add_audit(post, options)
+        return unless options[:ip].present?
+
+        post[:audit] = {}
+        post[:audit][:user_i_p] = options[:ip]
+      end
+
+      def add_return_url(post, options)
+        post[:return_url] = options[:return_url]
+      end
+
+      def parse(body)
+        JSON.parse(body).deep_transform_keys { |key| key.underscore.to_sym }
+      end
+
+      def headers(options = {})
+        headers = {}
+        headers['Authorization'] =
+          "Bearer #{options[:access_token]}" if options[:access_token]
+        headers['Content-Type'] = 'application/json'
+        headers
+      end
+
+      def commit(action, parameters, options = {})
+        url =
+          build_url(
+            action,
+            parameters.merge(service: options[:service] || @service)
+          )
+
+        begin
+          response =
+            parse(
+              ssl_request(
+                verb(action),
+                url,
+                post_data(action, parameters),
+                headers(options)
+              )
+            )
+        rescue ResponseError => e
+          # No gateway error message so we throw
+          raise if e.response.body.blank?
+
+          response = parse(e.response.body)
+        end
+
+        if action == :token
+          PayrixResponse.new(
+            token_success_from(response),
+            token_message_from(response),
+            response,
+            error_code: token_error_code_from(response),
+            fraud_review: token_fraud_review_from(response),
+            test: test?
+          )
+        else
+          PayrixResponse.new(
+            success_from(response),
+            message_from(response),
+            response,
+            error_code: error_code_from(response),
+            test: test?
+          )
+        end
+      end
+
+      def create_access_token_request
+        { username: options[:login], password: options[:password] }
+      end
+
+      def verb(action)
+        return :get if action == :token
+
+        :post
+      end
+
+      def build_url(action, parameters)
+        return test? ? test_auth_url : auth_url if action == :access_token
+
+        base_url = (test? ? test_url : live_url)
+        endpoint = ENDPOINTS[@service]
+        endpoint = parameters[:id] if parameters[:id] && action == :token
+
+        "#{base_url}/businesses/#{@business_id}/services/tokens/#{endpoint}"
+      end
+
+      def success_from(response)
+        !response.key?(:error_code)
+      end
+
+      def message_from(response)
+        success_from(response) ? 'Succeeded' : response[:error_message]
+      end
+
+      def authorization_from(response)
+        nil
+      end
+
+      def error_code_from(response)
+        unless success_from(response)
+          STANDARD_ERROR_CODE_MAPPING[response[:error_code]] ||
+            response[:error_code].to_s.underscore
+        end
+      end
+
+      def token_error_code_from(response)
+        unless token_success_from(response)
+          STANDARD_ERROR_CODE_MAPPING[response[:status]] || response[:status]
+        end
+      end
+
+      def token_success_from(response)
+        response[:status] == TOKEN_STATUS[:processed_successful]
+      end
+
+      def token_message_from(response)
+        if response[:transaction].nil?
+          TOKEN_STATUS_DESCRIPTIONS[response[:status_description]]
+        else
+          REJECTION_REASONS[response[:transaction][:sub_status_code]]
+        end
+      end
+
+      def token_fraud_review_from(response)
+        response[:status] == TOKEN_STATUS[:fraud_check_decline]
+      end
+
+      def access_token(r)
+        r.params.dig('access_token')
+      end
+
+      def post_data(action, parameters = {})
+        return nil if verb(action) == :get
+
+        if TRANSACTION_TYPES[action]
+          parameters[:transaction][:process_type] = TRANSACTION_TYPES[action]
+        end
+
+        parameters.deep_transform_keys { |key| key.to_s.camelize }.to_json
+      end
+
+      def trim(str, length = 100)
+        truncate(str, length)
+      end
+
+      def store?
+        !!@options[:store]
+      end
+
+      class PayrixResponse < Response
+        def token
+          @params['token']
+        end
+
+        def redirect_url
+          @params['redirect_to_url']
+        end
+      end
+    end
+  end
+end

data/lib/activemerchant/payrix/version.rb

@@ -0,0 +1,5 @@
+module ActiveMerchant
+  module Payrix
+    VERSION = '0.0.1'
+  end
+end

data/lib/activemerchant-payrix.rb

@@ -0,0 +1,3 @@
+require 'active_merchant'
+require 'activemerchant/payrix/version'
+require 'activemerchant/billing/gateways/payrix'

data/test/comm_stub.rb

@@ -0,0 +1,57 @@
+module CommStub
+  class Stub
+    def initialize(gateway, method_to_stub, action)
+      @gateway = gateway
+      @action = action
+      @complete = false
+      @method_to_stub = method_to_stub
+      @check = nil
+    end
+
+    def check_request(&block)
+      @check = block
+      self
+    end
+
+    def respond_with(*responses)
+      @complete = true
+      check = @check
+      singleton_class =
+        (
+          class << @gateway
+            self
+          end
+        )
+      singleton_class.send(:undef_method, @method_to_stub)
+      singleton_class.send(:define_method, @method_to_stub) do |*args|
+        check&.call(*args)
+        (responses.size == 1 ? responses.last : responses.shift)
+      end
+      @action.call
+    end
+
+    def complete?
+      @complete
+    end
+
+    class Complete
+      def complete?
+        true
+      end
+    end
+  end
+
+  def last_comm_stub
+    @last_comm_stub ||= Stub::Complete.new
+  end
+
+  def stub_comms(gateway = @gateway, method_to_stub = :ssl_post, &action)
+    assert last_comm_stub.complete?,
+           "Tried to stub communications when there's a stub already in progress."
+    @last_comm_stub = Stub.new(gateway, method_to_stub, action)
+  end
+
+  def teardown
+    assert(last_comm_stub.complete?)
+  end
+end

data/test/fixtures.yml

@@ -0,0 +1,5 @@
+payrix:
+  login: 90024.1456
+  password: PASSWORD
+  business_id: 90024
+  service: hpp