solidus_six_saferpay 0.1.0

data/config/locales/de.yml

@@ -0,0 +1,52 @@
+---
+de:
+  spree:
+    solidus_six_saferpay:
+      checkout: &checkout
+        init:
+          checkout_not_initialized: Zahlung konnte nicht gestartet werden.
+        success:
+          payment_source_not_created: Six Saferpay Zahlungsquelle konnte nicht erstellt werden.
+        fail:
+          payment_failed: Die Zahlung konnte nicht abgeschlossen werden.
+      payment_page:
+        checkout:
+          <<: *checkout
+      transaction:
+        checkout:
+          <<: *checkout
+  solidus_six_saferpay:
+    errors:
+      general_error: Bezahlungsfehler
+      liability_shift_not_granted:  Haftungsumkehr wurde abgelehnt
+  six_saferpay:
+    error_names:
+      ACTION_NOT_SUPPORTED: Die angeforderte Aktion wird im Kontext der Aktion nicht unterstützt un kann mit den Anforderungsdaten nicht ausgeführt werden.
+      ALIAS_INVALID: Der Alias ist nicht bekannt oder wird bereits verwendet (bei Registrierung).
+      AMOUNT_INVALID: Der Betrag entspricht nicht den Einschränkungen für diese Aktion.
+      AUTHENTICATION_FAILED: Falsches Password, falsches Client-Zertifikat, ungültiges Token, falscher HMAC.
+      BLOCKED_BY_RISK_MANAGEMENT: Aktion vom Risikomanagement gesperrt.
+      CARD_CHECK_FAILED: Ungültige Kartennummer oder CVC.
+      CARD_CVC_INVALID: Falscher CVC eingegeben.
+      CARD_CVC_REQUIRED: CVC nicht eingegeben, aber erforderlich.
+      CARD_EXPIRED: Karte abgelaufen.
+      COMMUNICATION_FAILED: Die Kommunikation zum Prozessor ist fehlgeschlagen.
+      COMMUNICATION_TIMEOUT: Saferpay hat nicht rechtzeitig eine Antwort vom externen System erhalten. Es ist möglich, dass eine Autorisierung erstellt wurde, aber Saferpay kann dies nicht wissen.
+      CONDITION_NOT_SATISFIED: Die in der Anfrage definierte Bedingung konnte nicht erfüllt werden.
+      CURRENCY_INVALID: Währung stimmt nicht mit der Währungstransaktion überein.
+      GENERAL_DECLINED: Transaktion aus einem unbekannten Grund abgelehnt.
+      INTERNAL_ERROR: Interner Fehler in Saferpay.
+      NO_CONTRACT: Für die Kombination aus Marke und Währung ist kein Vertrag verfügbar.
+      NO_CREDITS_AVAILABLE: Für dieses Konto ist kein Guthaben mehr verfügbar.
+      PAYMENTMEANS_INVALID: Ungültiges Zahlungsmittel (z. B. ungültige Karte).
+      PERMISSION_DENIED: Keine Berechtigung (z. B. Terminal gehört nicht dem Kunden).
+      3DS_AUTHENTICATION_FAILED: Die 3D-sichere Authentifizierung ist fehlgeschlagen - die Transaktion muss abgebrochen werden.
+      TOKEN_EXPIRED: Das Token ist abgelaufen.
+      TOKEN_INVALID: Das Token ist für diesen Kunden nicht vorhanden oder wird bereits verwendet.
+      TRANSACTION_ABORTED: Die Transaktion wurde von Kundin/Kunde abgebrochen.
+      TRANSACTION_ALREADY_CAPTURED: Transaktion bereits erfasst.
+      TRANSACTION_DECLINED: Vom Prozessor abgelehnt.
+      TRANSACTION_IN_WRONG_STATE: Transaktion befindet sich in falschem Zustand.
+      TRANSACTION_NOT_FOUND: Transaktion konnte nicht gefunden werden.
+      TRANSACTION_NOT_STARTED: Die Transaktion wurde noch nicht von der Bezahlung gestartet. Daher ist kein endgültiges Ergebnis für die Transaktion verfügbar.
+      VALIDATION_FAILED: Validierung fehlgeschlagen.

data/config/locales/en.yml

@@ -0,0 +1,52 @@
+---
+en:
+  spree:
+    solidus_six_saferpay:
+      checkout: &checkout
+        init:
+          checkout_not_initialized: Payment could not be initialized.
+        success:
+          payment_source_not_created: Six Saferpay payment source could not be created.
+        fail:
+          payment_failed: The payment could not be completed.
+      payment_page:
+        checkout:
+          <<: *checkout
+      transaction:
+        checkout:
+          <<: *checkout
+  solidus_six_saferpay:
+    errors:
+      general_error: Payment Error
+      liability_shift_not_granted:  Liability Shift was rejected
+  six_saferpay:
+    error_names:
+      ACTION_NOT_SUPPORTED:	The requested action is not supported in the given context or the action can't be executed with the request data.
+      ALIAS_INVALID:	The alias is not known or already used (in case of registration).
+      AMOUNT_INVALID:	The amount does not adhere to the restrictions for this action.
+      AUTHENTICATION_FAILED:	Wrong password, wrong client certificate, invalid token, wrong HMAC.
+      BLOCKED_BY_RISK_MANAGEMENT:	Action blocked by risk management.
+      CARD_CHECK_FAILED:	Invalid card number or cvc.
+      CARD_CVC_INVALID:	Wrong cvc entered.
+      CARD_CVC_REQUIRED:	Cvc not entered but required.
+      CARD_EXPIRED:	Card expired.
+      COMMUNICATION_FAILED:	The communication to the processor failed.
+      COMMUNICATION_TIMEOUT:	Saferpay did not receive a response from the external system in time. It’s possible that an authorization was created, but Saferpay is not able to know this.
+      CONDITION_NOT_SATISFIED:	The condition which was defined in the request could not be satisfied.
+      CURRENCY_INVALID:	Currency does not match referenced transaction currency.
+      GENERAL_DECLINED:	Transaction declined by unknown reason.
+      INTERNAL_ERROR:	Internal error in Saferpay.
+      NO_CONTRACT:	No contract available for the brand / currency combination.
+      NO_CREDITS_AVAILABLE:	No more credits available for this account.
+      PAYMENTMEANS_INVALID:	Invalid means of payment (e.g. invalid card).
+      PERMISSION_DENIED:	No permission (e.g. terminal does not belong to the customer).
+      3DS_AUTHENTICATION_FAILED:	3D-secure authentication failed – the transaction must be aborted.
+      TOKEN_EXPIRED:	The token is expired.
+      TOKEN_INVALID:	The token either does not exist for this customer or was already used.
+      TRANSACTION_ABORTED:	The transaction was aborted by the payer.
+      TRANSACTION_ALREADY_CAPTURED:	Transaction already captured.
+      TRANSACTION_DECLINED:	Declined by the processor.
+      TRANSACTION_IN_WRONG_STATE:	Transaction is in the wrong state.
+      TRANSACTION_NOT_FOUND:	Transaction could not be found.
+      TRANSACTION_NOT_STARTED:	The transaction was not started by the payer. Therefore, no final result for the transaction is available.
+      VALIDATION_FAILED:	Validation failed.

data/config/locales/fr.yml

@@ -0,0 +1,51 @@
+---
+fr:
+  spree:
+    solidus_six_saferpay:
+      checkout: &checkout
+        init:
+          checkout_not_initialized: Le paiement n'a pas pu être initialisé.
+        success:
+          payment_source_not_created: La source de paiement Six Saferpay n'a pas pu être créée.
+        fail:
+          payment_failed: Le paiement n'a pas pu être complété.
+      payment_page:
+        checkout:
+          <<: *checkout
+      transaction:
+        checkout:
+          <<: *checkout
+  solidus_six_saferpay:
+    errors:
+      liability_shift_not_granted:  Le transfert de responsabilité a été rejeté
+  six_saferpay:
+    error_names:
+      ACTION_NOT_SUPPORTED: l'action demandé n'es pas prise en charge dans le contexte de l'action et ne peut pas être exécutée avec les données de la demande.
+      ALIAS_INVALID: l'alias es inconnu ou est déjà utilisé (à l'enregistrement).
+      AMOUNT_INVALID: le mentant ne correspond pas aux restrictions pour cette action.
+      AUTHENTICATION_FAILED: Mot de passe incorrect, certificat client incorrect, jeton non valide, HMAC incorrect.
+      BLOCKED_BY_RISK_MANAGEMENT: action bloquée par la gestion des risques.
+      CARD_CHECK_FAILED: Numéro de carte ou CVC non valide.
+      CARD_CVC_INVALID: CVC incorrect entré.
+      CARD_CVC_REQUIRED: CVC non entré, mais obligatoire.
+      CARD_EXPIRED: La carte a expiré.
+      COMMUNICATION_FAILED: la communication avec le processeur a échoué.
+      COMMUNICATION_TIMEOUT: Saferpay n'a pas reçu de réponse du système externe à temps. Il est possible qu'une autorisation ait été créée, mais Saferpay ne peut pas le savoir.
+      CONDITION_NOT_SATISFIED: la condition définie dans la demande n'a pas pu être remplie.
+      CURRENCY_INVALID: la devise ne correspond pas à la transaction de devise.
+      GENERAL_DECLINED: transaction rejetée pour une raison inconnue.
+      INTERNAL_ERROR: erreur interne dans Saferpay.
+      NO_CONTRACT: Il n'y a pas de contrat pour la combinaison marque / devise.
+      NO_CREDITS_AVAILABLE: plus aucun crédit disponible pour ce compte.
+      PAYMENTMEANS_INVALID: Offre non valide (par exemple, carte invalide).
+      PERMISSION_DENIED: Aucune autorisation (par exemple, le terminal n'est pas la propriété du client).
+      3DS_AUTHENTICATION_FAILED: L'authentification 3D Secure a échoué - la transaction doit être abandonnée.
+      TOKEN_EXPIRED: le jeton a expiré.
+      TOKEN_INVALID: le jeton n'existe pas pour ce client ou est déjà utilisé.
+      TRANSACTION_ABORTED: La transaction a été annulée par le paiement.
+      TRANSACTION_ALREADY_CAPTURED: transaction déjà enregistrée.
+      TRANSACTION_DECLINED: rejeté par le processeur.
+      TRANSACTION_IN_WRONG_STATE: La transaction est dans un état incorrect.
+      TRANSACTION_NOT_FOUND: La transaction n'a pas pu être trouvée.
+      TRANSACTION_NOT_STARTED: La transaction n'a pas encore été lancée depuis le paiement. Par conséquent, aucun résultat final n'est disponible pour la transaction.
+      VALIDATION_FAILED: la validation a échoué.

data/config/routes.rb

@@ -0,0 +1,17 @@
+Spree::Core::Engine.routes.draw do
+
+  namespace :solidus_six_saferpay do
+    namespace :payment_page do
+      get :init, controller: :checkout, defaults: { format: :json }
+      get :success, controller: :checkout
+      get :fail, controller: :checkout
+    end
+
+    namespace :transaction do
+      get :init, controller: :checkout, defaults: { format: :json }
+      get :success, controller: :checkout
+      get :fail, controller: :checkout
+    end
+  end
+
+end

data/db/migrate/20190523075638_create_six_saferpay_payments.rb

@@ -0,0 +1,31 @@
+class CreateSixSaferpayPayments < ActiveRecord::Migration[5.1]
+  def change
+    create_table :spree_six_saferpay_payments do |t|
+      t.references :order
+      t.references :payment_method
+
+      t.string :token
+      t.datetime :expiration
+      t.string :redirect_url
+      t.string :transaction_id
+      t.string :transaction_status
+      t.datetime :transaction_date
+      t.string :six_transaction_reference
+      t.string :display_text
+      t.string :masked_number
+      t.string :expiration_year
+      t.string :expiration_month
+      t.text :response_hash
+
+      t.timestamps
+    end
+
+    add_index :spree_six_saferpay_payments, :token, unique: true
+    add_index :spree_six_saferpay_payments, :transaction_id, unique: true
+    add_index :spree_six_saferpay_payments, :six_transaction_reference, unique: true
+
+    # hack around foreign_key restriction by manually defining them
+    add_foreign_key :spree_six_saferpay_payments, :spree_orders, column: :order_id
+    add_foreign_key :spree_six_saferpay_payments, :spree_payment_methods, column: :payment_method_id
+  end
+end

data/lib/generators/solidus_six_saferpay/install/install_generator.rb

@@ -0,0 +1,20 @@
+module SolidusSixSaferpay
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      class_option :auto_run_migrations, type: :boolean, default: false
+
+      def add_migrations
+        run 'bundle exec rake railties:install:migrations FROM=solidus_six_saferpay'
+      end
+
+      def run_migrations
+        run_migrations = options[:auto_run_migrations] || ['', 'y', 'Y'].include?(ask('Would you like to run the migrations now? [Y/n]'))
+        if run_migrations
+          run 'bundle exec rake db:migrate'
+        else
+          puts 'Skipping rake db:migrate, don\'t forget to run it!'
+        end
+      end
+    end
+  end
+end

data/lib/solidus_six_saferpay.rb

@@ -0,0 +1,5 @@
+require 'solidus_core'
+require "solidus_support"
+
+require "solidus_six_saferpay/engine"
+require 'six_saferpay'

data/lib/solidus_six_saferpay/configuration.rb

@@ -0,0 +1,12 @@
+module SolidusSixSaferpay
+
+  class Configuration
+    def self.config
+      yield(self)
+    end
+
+    def self.error_handlers
+      @error_handlers ||= []
+    end
+  end
+end

data/lib/solidus_six_saferpay/engine.rb

@@ -0,0 +1,25 @@
+module SolidusSixSaferpay
+  class Engine < ::Rails::Engine
+    isolate_namespace SolidusSixSaferpay
+
+    config.autoload_paths += Dir["#{config.root}/lib/**/"]
+    config.eager_load_paths += Dir["#{config.root}/lib/**/"]
+
+    initializer "spree.six_payment.payment_methods", :after => "spree.register.payment_methods" do |app|
+      app.config.spree.payment_methods << Spree::PaymentMethod::SaferpayPaymentPage
+      app.config.spree.payment_methods << Spree::PaymentMethod::SaferpayTransaction
+    end
+
+    initializer "solidus_six_payments.assets.precompile" do |app|
+      app.config.assets.precompile += %w( solidus_six_saferpay/application.css )
+      app.config.assets.precompile += %w( solidus_six_saferpay/saferpay_payment.js )
+      app.config.assets.precompile += %w( solidus_six_saferpay/credit_cards/**/*.png )
+    end
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.fixture_replacement :factory_bot
+      g.factory_bot dir: 'spec/factories'
+    end
+  end
+end

data/lib/solidus_six_saferpay/error_handler.rb

@@ -0,0 +1,21 @@
+module SolidusSixSaferpay
+
+  class ErrorHandler
+    # Use a custom error handler so that host applications can configure their
+    # error handling
+    def self.handle(error, level: :error)
+      Rails.logger.send(level, error)
+
+      Configuration.error_handlers.each do |handler|
+        if !handler.respond_to?(:call)
+          Rails.logger.warn("SolidusSixSaferpay::Configuration ERROR: The attached error handler #{handler} can not be called with #{handler}.call(error, level: level)")
+
+          # skip to next handler
+          next
+        end
+        handler.call(error, level: level)
+      end
+    end
+  end
+end
+

data/lib/solidus_six_saferpay/gateway.rb

@@ -0,0 +1,183 @@
+module SolidusSixSaferpay
+  class Gateway
+
+    include Spree::RouteAccess
+
+    def initialize(options = {})
+      SixSaferpay.configure do |config|
+        config.success_url = options.fetch(:success_url)
+        config.fail_url = options.fetch(:fail_url)
+
+        # Allow config via ENV for static values
+        config.customer_id = options.fetch(:customer_id) { ENV.fetch('SIX_SAFERPAY_CUSTOMER_ID') }
+        config.terminal_id = options.fetch(:terminal_id) { ENV.fetch('SIX_SAFERPAY_TERMINAL_ID') }
+        config.username = options.fetch(:username) { ENV.fetch('SIX_SAFERPAY_USERNAME') }
+        config.password = options.fetch(:password) { ENV.fetch('SIX_SAFERPAY_PASSWORD') }
+        config.base_url = options.fetch(:base_url) { ENV.fetch('SIX_SAFERPAY_BASE_URL') }
+        config.css_url = options.fetch(:css_url) { ENV.fetch('SIX_SAFERPAY_CSS_URL') }
+      end
+    end
+
+    def initialize_payment(order, payment_method)
+      initialize_response = SixSaferpay::Client.post(
+        interface_initialize_object(order, payment_method)
+      )
+      response(
+        true,
+        "Saferpay Initialize Checkout response: #{initialize_response.to_h}",
+        initialize_response,
+      )
+    rescue SixSaferpay::Error => e
+      handle_error(e, initialize_response)
+    end
+
+    def authorize(amount, saferpay_payment, options = {})
+      raise NotImplementedError, "must be implemented in PaymentPageGateway or TransactionGateway"
+    end
+
+    def inquire(saferpay_payment, options = {})
+      raise NotImplementedError, "must be implemented in PaymentPageGateway or TransactionGateway"
+    end
+
+    def purchase(amount, saferpay_payment, options = {})
+      capture(amount, saferpay_payment.transaction_id, options)
+    end
+
+    def capture(amount, transaction_id, options={})
+      transaction_reference = SixSaferpay::TransactionReference.new(transaction_id: transaction_id)
+      payment_capture = SixSaferpay::SixTransaction::Capture.new(transaction_reference: transaction_reference)
+
+      capture_response = SixSaferpay::Client.post(payment_capture)
+
+      response(
+        true,
+        "Saferpay Payment Capture response: #{capture_response.to_h}",
+        capture_response,
+        { authorization: capture_response.capture_id }
+      )
+
+    rescue SixSaferpay::Error => e
+      handle_error(e, capture_response)
+    end
+
+    def void(transaction_id, options = {})
+      transaction_reference = SixSaferpay::TransactionReference.new(transaction_id: transaction_id)
+      payment_cancel = SixSaferpay::SixTransaction::Cancel.new(transaction_reference: transaction_reference)
+
+      cancel_response = SixSaferpay::Client.post(payment_cancel)
+
+      response(
+        true,
+        "Saferpay Payment Cancel response: #{cancel_response.to_h}",
+        cancel_response
+      )
+    rescue SixSaferpay::Error => e
+      handle_error(e, cancel_response)
+    end
+
+    def try_void(payment)
+      if payment.checkout? && payment.transaction_id
+        void(payment.transaction_id, originator: self)
+      end
+    end
+
+    # aliased to #refund for compatibility with solidus internals
+    def credit(amount, transaction_id, options = {})
+      refund(amount, transaction_id, options)
+    end
+
+    def refund(amount, transaction_id, options = {})
+      payment = Spree::Payment.find_by!(response_code: transaction_id)
+      refund_amount = Spree::Money.new(amount, currency: payment.currency)
+
+      saferpay_amount = SixSaferpay::Amount.new(value: refund_amount.cents, currency_code: payment.currency)
+      saferpay_refund = SixSaferpay::Refund.new(amount: saferpay_amount, order_id: payment.order.number)
+      capture_reference = SixSaferpay::CaptureReference.new(capture_id: payment.transaction_id)
+
+      payment_refund = SixSaferpay::SixTransaction::Refund.new(refund: saferpay_refund, capture_reference: capture_reference)
+
+      if refund_response = SixSaferpay::Client.post(payment_refund)
+
+        # actually capture the refund
+        capture(amount, refund_response.transaction.id, options)
+      end
+
+    rescue SixSaferpay::Error => e
+      handle_error(e, refund_response)
+    end
+
+    private
+
+    def interface_initialize_object(order, payment_method)
+      raise NotImplementedError, "Must be implemented in PaymentPageGateway or TransactionGateway"
+    end
+
+    def interface_initialize_params(order, payment_method)
+      amount = Spree::Money.new(order.total, currency: order.currency)
+      payment = SixSaferpay::Payment.new(
+        amount: SixSaferpay::Amount.new(value: amount.cents, currency_code: amount.currency.iso_code),
+        order_id: order.number,
+        description: order.number
+      )
+
+      billing_address = order.billing_address
+      billing_address = SixSaferpay::Address.new(
+        first_name: billing_address.first_name,
+        last_name: billing_address.last_name,
+        date_of_birth: nil,
+        company: nil,
+        gender: nil,
+        legal_form: nil,
+        street: billing_address.address1,
+        street2: billing_address.address2,
+        zip: billing_address.zipcode,
+        city: billing_address.city,
+        country_subdevision_code: nil,
+        country_code: billing_address.country.iso,
+        phone: nil,
+        email: nil,
+      )
+      shipping_address = order.shipping_address
+      delivery_address = SixSaferpay::Address.new(
+        first_name: shipping_address.first_name,
+        last_name: shipping_address.last_name,
+        date_of_birth: nil,
+        company: nil,
+        gender: nil,
+        legal_form: nil,
+        street: shipping_address.address1,
+        street2: shipping_address.address2,
+        zip: shipping_address.zipcode,
+        city: shipping_address.city,
+        country_subdevision_code: nil,
+        country_code: shipping_address.country.iso,
+        phone: nil,
+        email: nil,
+      )
+      payer = SixSaferpay::Payer.new(language_code: I18n.locale, billing_address: billing_address, delivery_address: delivery_address)
+
+      params = { payment: payment, payer: payer }
+
+      six_payment_methods = payment_method.enabled_payment_methods
+      params.merge!(payment_methods: six_payment_methods) unless six_payment_methods.blank?
+
+      params
+    end
+
+    def response(success, message, api_response, options = {})
+      GatewayResponse.new(success, message, api_response, options)
+    end
+
+    def handle_error(error, response)
+      # Call host error handler hook
+      SolidusSixSaferpay::ErrorHandler.handle(error, level: :error)
+
+      response(
+        false,
+        error.error_message,
+        response,
+        error_name: error.error_name
+      )
+    end
+  end
+end