barion 0.2.0

data/app/models/barion/payment_transaction.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: barion_payment_transactions
+#
+#  id                    :integer          not null, primary key
+#  comment               :string
+#  currency              :string(3)
+#  payee                 :string           not null
+#  payer                 :string
+#  status                :integer          default("prepared"), not null
+#  total                 :decimal(, )      not null
+#  transaction_time      :datetime
+#  transaction_type      :integer
+#  created_at            :datetime         not null
+#  updated_at            :datetime         not null
+#  payee_transactions_id :bigint
+#  payment_id            :bigint
+#  pos_transaction_id    :string           not null
+#  related_id            :string
+#  transaction_id        :string
+#
+# Indexes
+#
+#  index_barion_payment_transactions_on_payee                  (payee)
+#  index_barion_payment_transactions_on_payee_transactions_id  (payee_transactions_id)
+#  index_barion_payment_transactions_on_payment_id             (payment_id)
+#  index_barion_payment_transactions_on_pos_transaction_id     (pos_transaction_id)
+#  index_barion_payment_transactions_on_status                 (status)
+#  index_barion_payment_transactions_on_transaction_id         (transaction_id)
+#
+# Foreign Keys
+#
+#  payee_transactions_id  (payee_transactions_id => barion_payment_transactions.id)
+#  payment_id             (payment_id => barion_payments.id)
+#
+module Barion
+  # Barion Transaction implementation
+  class PaymentTransaction < ApplicationRecord
+    include ::Barion::Currencies
+    include ::Barion::JsonSerializer
+
+    enum status: {
+      prepared: 0, started: 1, succeeded: 2, timeout: 3, shop_is_deleted: 4,
+      shop_is_closed: 5, rejected: 6, rejected_by_shop: 12, storno: 13, reserved: 14,
+      deleted: 15, expired: 16, authorized: 17, reversed: 18, invalid_payment_record: 210,
+      payment_time_out: 211, invalid_payment_status: 212,
+      payment_sender_or_recipient_is_invalid: 213, unknown: 255
+    }, _default: :prepared
+    enum transaction_type: {
+      shop: 1, transfer_to_existing_user: 2, transfer_to_technical_account: 3,
+      reserve: 16, storno_reserve: 17, card_processing_fee: 21, gateway_fee: 22,
+      card_processing_fee_storno: 23, unspecified: 100, card_payment: 150,
+      refund: 151, refund_to_bank_card: 152, storno_un_successful_refund_to_bank_card: 153,
+      under_review: 180, release_review: 190, bank_transfer_payment: 200,
+      refund_to_bank_account: 201, storno_un_successful_refund_to_bank_account: 202,
+      bank_transfer_payment_fee: 203
+    }
+
+    belongs_to :payment, inverse_of: :payment_transactions
+    has_many :items,
+             inverse_of: :payment_transaction,
+             after_add: :calc_total,
+             after_remove: :calc_total
+    attribute :total, :decimal, default: 0.0
+    attribute :pos_transaction_id, :string
+
+    validates :payee, presence: true
+    validates :status, presence: true
+    validates :pos_transaction_id, presence: true
+    validates :items, presence: true
+    validates_associated :items
+
+    after_initialize :set_defaults
+
+    def currency=(val = nil)
+      super(val || payment&.currency)
+    end
+
+    def set_defaults
+      self.currency = payment&.currency if currency.nil?
+      self.payee = ::Barion.default_payee if payee.nil?
+    end
+
+    def total=(value)
+      value = calc_item_totals if value.nil?
+      super(value)
+    end
+
+    def serialize_options
+      { except: %i[id status created_at updated_at transaction_type related_id],
+        include: %i[items],
+        map: {
+          keys: {
+            _all: :camelize,
+            pos_transaction_id: 'POSTransactionId'
+          },
+          values: {
+            _all: proc { |v| v.respond_to?(:camelize) ? v.camelize : v },
+            _except: %w[items pos_transaction_id payee comment]
+          }
+        } }
+    end
+
+    def deserialize_options
+      {
+        except: %i[items],
+        map: {
+          keys: {
+            _all: :underscore,
+            POSTransactionId: 'pos_transaction_id'
+          },
+          values: {
+            _all: proc { |v| v.respond_to?(:underscore) ? v.underscore : v },
+            _except: %w[Currency]
+          }
+        }
+      }
+    end
+
+    protected
+
+    def calc_item_totals
+      items.sum(&:item_total)
+    end
+
+    private
+
+    def calc_total(_item)
+      self.total = calc_item_totals
+    end
+  end
+end

data/app/models/barion/purchase.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: barion_purchases
+#
+#  id                         :integer          not null, primary key
+#  availability_indicator     :integer
+#  delivery_email_address     :string
+#  delivery_timeframe         :integer
+#  pre_order_date             :datetime
+#  purchase_date              :datetime
+#  purchase_type              :integer
+#  re_order_indicator         :integer
+#  recurring_expiry           :datetime
+#  recurring_frequency        :integer
+#  shipping_address_indicator :integer
+#  created_at                 :datetime         not null
+#  updated_at                 :datetime         not null
+#  payment_id                 :bigint
+#
+# Indexes
+#
+#  index_barion_purchases_on_delivery_email_address  (delivery_email_address)
+#  index_barion_purchases_on_delivery_timeframe      (delivery_timeframe)
+#  index_barion_purchases_on_payment_id              (payment_id)
+#
+module Barion
+  # Represents a purchase in Barion engine
+  class Purchase < ApplicationRecord
+    include ::Barion::JsonSerializer
+
+    enum availability_indicator: {
+      merchandise_available: 0,
+      future_availability: 10
+    }, _default: :merchandise_available
+
+    attr_accessor :delivery_email_address
+
+    enum delivery_timeframe: {
+      electronic_delivery: 0,
+      same_day_shipping: 10,
+      overnight_shipping: 20,
+      two_day_or_more_shipping:	30
+    }
+    enum re_order_indicator: {
+      first_time_ordered: 0,
+      reordered: 10
+    }
+    enum shipping_address_indicator: {
+      ship_to_cardholders_billing_address: 0,
+      ship_to_another_verified_address: 10,
+      ship_to_different_address: 20,
+      ship_to_store: 30,
+      digital_goods: 40,
+      travel_and_event_tickets: 50,
+      other: 60
+    }
+    enum purchase_type: {
+      goods_and_service_purchase: 0,
+      check_acceptance: 1,
+      account_funding: 2,
+      quasi_cash_transaction: 3,
+      pre_paid_vacation_and_loan: 4
+    }
+
+    belongs_to :payment, inverse_of: :purchase_information
+    has_one :gift_card_purchase
+
+    validates :recurring_frequency,
+              numericality: { only_integer: true },
+              inclusion: { in: 0..9_999 },
+              allow_nil: true
+
+    with_options if: :initial_recurring_payment? do |purchase|
+      purchase.validates :recurring_frequency, presence: true
+      purchase.validates :recurring_expiry, presence: true
+    end
+
+    def serialize_options
+      { except: %i[id created_at updated_at],
+        include: %i[gift_card_purchase],
+        map: {
+          keys: {
+            _all: :camelize
+          },
+          values: {
+            _all: proc { |v| v.respond_to?(:camelize) ? v.camelize : v },
+            pre_order_date: :as_datetime,
+            recurring_expiry: :as_datetime,
+            purchase_date: :as_datetime,
+            availability_indicator: :as_enum_id,
+            delivery_timeframe: :as_enum_id,
+            re_order_indicator: :as_ennum_id,
+            shipping_address_indicator: :as_enum_id,
+            purchase_type: :as_enum_id
+          }
+        } }
+    end
+
+    private
+
+    def initial_recurring_payment?
+      payment.recurring? and payment.initiate_recurrence
+    end
+  end
+end

data/app/models/concerns/barion/currencies.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Barion
+  # Common data formats in Barion
+  module Currencies
+    extend ActiveSupport::Concern
+    included do
+      enum currency: { EUR: 'EUR', USD: 'USD', HUF: 'HUF', CZK: 'CZK' }, _default: :HUF
+    end
+  end
+end

data/app/models/concerns/barion/data_formats.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Barion
+  # Common data formats in Barion
+  module DataFormats
+    extend ActiveSupport::Concern
+
+    def self.phone_number(number)
+      number.sub(/^\+/, '').sub(/^00/, '')[0..29]
+    end
+  end
+end

data/app/models/concerns/barion/json_serializer.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Barion
+  # JSON serialization solution for Barion
+  module JsonSerializer
+    extend ActiveSupport::Concern
+
+    def serialize_options
+      {}
+    end
+
+    def deserialize_options
+      {}
+    end
+
+    def key_names
+      {}
+    end
+
+    def serializable_hash(options = {})
+      options ||= serialize_options
+      result = super(serialize_options.merge(options))
+      if serialize_options.key?(:map)
+        map = serialize_options[:map]
+        convert_values(result, map[:values], &map[:values][:_all]) if map.key?(:values)
+        convert_keys(result, map[:keys], &map[:keys][:_all]) if map.key?(:keys)
+      end
+      result.compact!
+    end
+
+    def deserialize(hash, options = {})
+      options ||= deserialize_options
+      deserialize_options.merge(options)
+      return unless deserialize_options.key?(:map)
+
+      map = deserialize_options[:map]
+      convert_values(hash, map[:values], &map[:values][:_all]) if map.key?(:values)
+      return unless map.key?(:keys)
+
+      convert_keys(hash, map[:keys], &map[:keys][:_all])
+    end
+
+    def process_response(response)
+      exceptions = deserialize_options.fetch(:except, {})
+      associations = deserialize_options.fetch(:assoc, {})
+
+      hash = deserialize(response)
+      hash.map do |key, value|
+        next if exceptions.include?(key.to_sym)
+
+        association = self.class.reflect_on_association(key)
+        if association
+          (model_key_name, key_name) = associations[key.to_sym].shift
+          value.each do |params|
+            id = params[key_name]
+            item = association.klass.send("find_by_#{model_key_name}", id)
+            item.send(:process_response, params.compact!)
+          end
+        elsif respond_to?("#{key}=")
+          send("#{key}=", value)
+        end
+      end
+    end
+
+    private
+
+    def convert_keys(hash, map, &block)
+      hash.transform_keys! { |k| map.fetch(k.to_sym, k) unless k.nil? }
+      hash.transform_keys!(&block) if block_given?
+    end
+
+    def convert_values(hash, map, &block)
+      hash.each do |k, v|
+        ks = k.to_sym
+        hash[k] = send(map[ks], ks, v) if v.present? && map.key?(ks) && respond_to?(map[ks], true)
+      end
+      hash_exceptions = hash.slice(*map[:_except])
+      hash.transform_values!(&block) if block_given?
+      hash.merge!(hash_exceptions)
+    end
+
+    def as_time(_, sec)
+      day, sec = sec.divmod(1.days)
+      hour, sec = sec.divmod(1.hour)
+      min, sec = sec.divmod(1.minute)
+      format('%<day>d.%02<hour>d:%02<min>d:%02<sec>d', day: day, hour: hour, min: min, sec: sec)
+    end
+
+    def as_datetime(_, date)
+      date.as_json.delete_suffix('Z')
+    end
+
+    def as_list(_, string)
+      string.camelize.split(',')
+    end
+
+    def as_enum_id(enum, id)
+      hash = self.class.send(enum.to_s.pluralize)
+      hash.fetch(id)
+    end
+
+    def as_string(_, value)
+      value.to_s
+    end
+  end
+end

data/app/views/barion/main/land.html.erb

@@ -0,0 +1,7 @@
+<h1>Payment <%= @payment.status.to_s.camelize %></h1>
+<dl>
+  <dt>Request id:</dt>
+  <dd><%= @payment.payment_request_id %></dd>
+  <dt>Order number:</dt>
+  <dd><%= @payment.order_number %></dd>
+</dl>

data/config/initializers/barion.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# ::Barion.config do |shop|
+#  shop.poskey = 'test'
+#  shop.publickey = 'test2'
+#  shop.sandbox = true
+#  shop.acronym = ''
+#  shop.default_payee = 'me@example.org'
+# end

data/config/routes.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# == Route Map
+#
+
+::Barion::Engine.routes.draw do
+  root to: 'main#land'
+  post 'callback', to: 'main#callback', as: :gateway_callback
+  get 'land', to: 'main#land', as: :gateway_back
+end

data/db/migrate/20201222235354_create_barion_payments.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Creates Barion::Payment record persistency
+class CreateBarionPayments < ActiveRecord::Migration[6.0]
+  def change
+    # rubocop:disable Metrics/BlockLength
+    create_table :barion_payments do |t|
+      t.string :poskey, index: true, null: false
+      t.integer :payment_type, index: true, default: 0, null: false
+      t.integer :reservation_period, limit: 8
+      t.integer :delayed_capture_period, limit: 6
+      t.string :payment_window, limit: 6
+      t.boolean :guest_check_out
+      t.boolean :initiate_recurrence
+      t.string :recurrence_id, limit: 100, index: true
+      t.integer :funding_sources, default: 0
+      t.string :payment_request_id, limit: 100, index: true
+      t.string :payer_hint, limit: 256
+      t.string :card_holder_name_hint, limit: 45
+      t.integer :recurrence_type, default: 0
+      t.string :trace_id, limit: 100
+      t.string :redirect_url, limit: 2000
+      t.string :callback_url, limit: 2000
+
+      t.string :order_number, limit: 100, index: true
+      t.string :locale, limit: 10, null: false
+      t.string :currency, limit: 3, null: false
+      t.string :payer_phone_number, limit: 30
+      t.string :payer_work_phone_number, limit: 30
+      t.string :payer_home_number, limit: 30
+      t.integer :challenge_preference, default: 0
+      t.string :checksum, null: false
+
+      t.string :payment_id, index: true
+      t.integer :status, index: true, null: false
+      t.string :qr_url, limit: 2000
+      t.integer :recurrence_result
+      t.string :gateway_url, limit: 2000
+
+      t.string :pos_id
+      t.string :pos_name
+      t.string :pos_owner_email
+      t.string :pos_owner_country
+      t.integer :funding_source
+      t.datetime :created_at_barion
+      t.datetime :started_at
+      t.datetime :completed_at
+      t.datetime :valid_until
+      t.datetime :reserved_until
+      t.datetime :delayed_capture_until
+      t.decimal :total
+      t.string :suggested_local
+      t.integer :fraud_risk_score
+
+      t.timestamps
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end