barion 0.2.0

data/app/models/barion/item.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: barion_items
+#
+#  id                     :integer          not null, primary key
+#  description            :string(500)      not null
+#  image_url              :string
+#  item_total             :decimal(, )      not null
+#  name                   :string(250)      not null
+#  quantity               :decimal(, )      not null
+#  sku                    :string(100)
+#  unit                   :string(50)       not null
+#  unit_price             :decimal(, )      not null
+#  payment_transaction_id :integer
+#
+# Indexes
+#
+#  index_barion_items_on_payment_transaction_id  (payment_transaction_id)
+#
+# Foreign Keys
+#
+#  payment_transaction_id  (payment_transaction_id => barion_payment_transactions.id)
+#
+module Barion
+  # Represents an item in a transaction for Barion engine
+  class Item < ApplicationRecord
+    include ::Barion::JsonSerializer
+
+    belongs_to :payment_transaction,
+               inverse_of: :items
+
+    attribute :name, :string
+    attribute :description, :string
+    attribute :unit_price, :decimal, default: 0.0
+    attribute :quantity, :decimal, default: 0.0
+    attribute :item_total, :decimal, default: 0.0
+    attribute :unit, :string
+
+    validates :name, presence: true, length: { maximum: 256 }
+    validates :description, presence: true, length: { maximum: 500 }
+    validates :quantity, presence: true
+    validates :unit_price, presence: true
+    validates :item_total, presence: true
+    validates :sku, length: { maximum: 100 }
+    validates :unit, presence: true, length: { maximum: 50 }
+
+    after_initialize :set_defaults
+
+    def serialize_options
+      {
+        except: %i[id updated_at created_at],
+        map: {
+          keys: {
+            _all: :camelize,
+            sku: 'SKU'
+          }
+        }
+      }
+    end
+
+    def unit_price=(value)
+      super(value.to_d)
+      calculate_total
+    end
+
+    def quantity=(value)
+      super(value.to_d)
+      calculate_total
+    end
+
+    def item_total=(value)
+      value = calculate_total if value.nil?
+      super(value)
+    end
+
+    private
+
+    def set_defaults
+      calculate_total
+    end
+
+    def calculate_total
+      self.item_total = (quantity * unit_price.to_d)
+    end
+  end
+end

data/app/models/barion/payer_account.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: barion_payer_accounts
+#
+#  id                               :integer          not null, primary key
+#  account_change_indicator         :integer
+#  account_created                  :datetime
+#  account_creation_indicator       :integer
+#  account_last_changed             :datetime
+#  password_change_indicator        :integer
+#  password_last_changed            :datetime
+#  payment_method_added             :datetime
+#  provision_attempts               :integer
+#  purchases_in_the_last_6_months   :integer
+#  shipping_address_added           :datetime
+#  shipping_address_usage_indicator :integer
+#  suspicious_activity_indicator    :integer          default("no_suspicious_activity_observed")
+#  transactional_activity_per_day   :integer
+#  transactional_activity_per_year  :integer
+#  created_at                       :datetime         not null
+#  updated_at                       :datetime         not null
+#  account_id                       :string(64)
+#  payment_id                       :bigint
+#
+# Indexes
+#
+#  index_barion_payer_accounts_on_account_id  (account_id)
+#  index_barion_payer_accounts_on_payment_id  (payment_id)
+#
+module Barion
+  # Represents a PayerAccount in Barion engine
+  class PayerAccount < ApplicationRecord
+    include ::Barion::DataFormats
+    include ::Barion::JsonSerializer
+
+    attribute :account_is, :string
+    enum account_change_indicator: {
+      changed_during_this_transaction: 0,
+      less_than_30_days: 10,
+      between_30_and_60_days: 20,
+      more_than_60_days: 30
+    }, _default: 0, _prefix: true
+    attribute :account_created, :datetime
+    enum account_creation_indicator: {
+      no_account: 0,
+      created_during_this_transaction: 10,
+      less_than_30_days: 20,
+      between_30_and_60_days: 30,
+      more_than_60_days: 40
+    }, _default: 0, _prefix: true
+    attribute :account_last_changed, :datetime
+    enum password_change_indicator: {
+      no_change: 0,
+      changed_during_this_transaction: 10,
+      less_than_30_days: 20,
+      between_30_and_60_days: 30,
+      more_than_60_days: 40
+    }, _default: 0, _prefix: true
+    attribute :password_last_changed, :datetime
+    attribute :payment_method_added, :boolean
+    attribute :provision_attempts, :integer
+    attribute :purchases_in_the_last_6_months, :integer
+    attribute :shipping_address_added, :datetime
+    enum shipping_address_usage_indicator: {
+      this_transaction: 0,
+      less_than_30_days: 10,
+      between_30_and_60_days: 20,
+      more_than_60_days: 30
+    }, _default: 0
+    enum suspicious_activity_indicator: {
+      no_suspicious_activity_observed: 0,
+      suspicious_activity_observed: 10
+    }, _default: 0
+    attribute :transactional_activity_per_day, :integer
+    attribute :transactional_activity_per_year, :integer
+
+    belongs_to :payment, inverse_of: :payer_account, dependent: :delete
+
+    validates :account_id, length: { maximum: 64 }, allow_nil: true
+    validates :provision_attempts,
+              numericality: true,
+              inclusion: { in: 0..999 },
+              allow_nil: true
+    validates :transactional_activity_per_day,
+              numericality: { only_integer: true },
+              inclusion: { in: 0..999 },
+              allow_nil: true
+    validates :purchases_in_the_last_6_months,
+              numericality: { only_integer: true },
+              inclusion: { in: 0..9999 },
+              allow_nil: true
+    validates :transactional_activity_per_year,
+              numericality: { only_integer: true },
+              inclusion: { in: 0..999 },
+              allow_nil: true
+
+    def serialize_options
+      { except: %i[id created_at updated_at],
+        map: {
+          keys: {
+            _all: :camelize
+          },
+          values: {
+            _all: proc { |v| v.respond_to?(:camelize) ? v.camelize : v },
+            account_created: :as_datetime,
+            account_last_changed: :as_datetime,
+            password_last_changed: :as_datetime,
+            account_change_indicator: :as_enum_id,
+            account_creation_indicator: :as_enum_id,
+            password_change_indicator: :as_enum_id,
+            shipping_address_usage_indicator: :as_enum_id,
+            suspicious_activity_indicator: :as_enum_id
+          }
+        } }
+    end
+  end
+end

data/app/models/barion/payment.rb

@@ -0,0 +1,348 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: barion_payments
+#
+#  id                      :integer          not null, primary key
+#  callback_url            :string(2000)
+#  card_holder_name_hint   :string(45)
+#  challenge_preference    :integer          default("no_preference")
+#  checksum                :string           not null
+#  completed_at            :datetime
+#  created_at_barion       :datetime
+#  currency                :string(3)        not null
+#  delayed_capture_period  :integer
+#  delayed_capture_until   :datetime
+#  fraud_risk_score        :integer
+#  funding_source          :integer
+#  funding_sources         :integer          default("all")
+#  gateway_url             :string(2000)
+#  guest_check_out         :boolean
+#  initiate_recurrence     :boolean
+#  locale                  :string(10)       not null
+#  order_number            :string(100)
+#  payer_hint              :string(256)
+#  payer_home_number       :string(30)
+#  payer_phone_number      :string(30)
+#  payer_work_phone_number :string(30)
+#  payment_type            :integer          default("immediate"), not null
+#  payment_window          :string(6)
+#  pos_name                :string
+#  pos_owner_country       :string
+#  pos_owner_email         :string
+#  poskey                  :string           not null
+#  qr_url                  :string(2000)
+#  recurrence_result       :integer
+#  recurrence_type         :integer          default(NULL)
+#  redirect_url            :string(2000)
+#  reservation_period      :integer
+#  reserved_until          :datetime
+#  started_at              :datetime
+#  status                  :integer          not null
+#  suggested_local         :string
+#  total                   :decimal(, )
+#  valid_until             :datetime
+#  created_at              :datetime         not null
+#  updated_at              :datetime         not null
+#  payment_id              :string
+#  payment_request_id      :string(100)
+#  pos_id                  :string
+#  recurrence_id           :string(100)
+#  trace_id                :string(100)
+#
+# Indexes
+#
+#  index_barion_payments_on_order_number        (order_number)
+#  index_barion_payments_on_payment_id          (payment_id)
+#  index_barion_payments_on_payment_request_id  (payment_request_id)
+#  index_barion_payments_on_payment_type        (payment_type)
+#  index_barion_payments_on_poskey              (poskey)
+#  index_barion_payments_on_recurrence_id       (recurrence_id)
+#  index_barion_payments_on_status              (status)
+#
+module Barion
+  # Represents a payment in Barion engine
+  class Payment < ApplicationRecord
+    include ::Barion::DataFormats
+    include ::Barion::Currencies
+    include ::Barion::JsonSerializer
+
+    enum locale: { 'cs-CZ': 'cs-CZ',
+                   'de-DE': 'de-DE',
+                   'en-US': 'en-US',
+                   'es-ES': 'es-ES',
+                   'fr-FR': 'fr-FR',
+                   'hu-HU': 'hu-HU',
+                   'sk-SK': 'sk-SK',
+                   'sl-SI': 'sl-SI' }, _default: 'hu-HU'
+    enum challenge_preference: {
+      no_preference: 0,
+      challenge_required: 10,
+      no_challenge_needed: 20
+    }, _default: :no_preference
+    enum recurrence_result: %i[none successful failed not_found], _prefix: true
+    enum payment_type: %i[immediate reservation delayed_capture], _default: :immediate
+    enum funding_sources: { all: 0, balance: 1 }, _suffix: true, _default: :all
+    enum recurrence_type: { one_click: 1, merchant_initiated: 2, recurring: 3 }
+    enum status: {
+      initial: 0,
+      prepared: 10,
+      started: 20,
+      in_progress: 21,
+      waiting: 22,
+      reserved: 25,
+      authorized: 26,
+      canceled: 30,
+      succeeded: 40,
+      failed: 50,
+      partially_succeeded: 60,
+      expired: 70
+    }, _default: :initial
+    attribute :payment_window, :integer, default: 30.minutes.to_i
+    attribute :guest_check_out, :boolean, default: true
+    attribute :initiate_recurrence, :boolean, default: false
+    attribute :phone_number, :string
+    attribute :home_number, :string
+    attribute :checksum, :string
+    enum funding_source: { balance: 1, bank_card: 2, bank_transfer: 3 }, _suffix: true
+
+    has_many :payment_transactions,
+             inverse_of: :payment,
+             dependent: :destroy
+
+    has_one :shipping_address,
+            class_name: '::Barion::Address',
+            inverse_of: :payment
+
+    has_one :billing_address,
+            class_name: '::Barion::Address',
+            inverse_of: :payment
+
+    has_one :payer_account, inverse_of: :payment
+
+    has_one :purchase_information,
+            class_name: '::Barion::Purchase',
+            inverse_of: :payment
+
+    validates :payment_type, presence: true
+    validates :reservation_period,
+              presence: true,
+              numericality: { only_integer: true },
+              inclusion: { in: 1.minute.to_i..1.year.to_i },
+              if: :reservation?
+    validates :delayed_capture_period,
+              presence: true,
+              numericality: { only_integer: true },
+              inclusion: { in: 1.minute.to_i..1.week.to_i },
+              if: :delayed_capture?
+    validates :delayed_capture_period,
+              absence: true,
+              unless: :delayed_capture?
+    validates :payment_window,
+              numericality: { only_integer: true },
+              inclusion: { in: 1.minute.to_i..1.week.to_i }
+    validates_uniqueness_of :payment_request_id
+    validates :recurrence_id, length: { maximum: 100 }
+    validates :payer_hint, length: { maximum: 256 }
+    validates :card_holder_name_hint,
+              length: { minimum: 2, maximum: 45 },
+              allow_nil: true
+    validates :trace_id, length: { maximum: 100 }
+    validates :redirect_url, length: { maximum: 2000 }
+    validates :callback_url, length: { maximum: 2000 }
+    validates :gateway_url, length: { maximum: 2000 }
+    validates :qr_url, length: { maximum: 2000 }
+    validates :order_number, length: { maximum: 100 }
+    validates :payer_hint, length: { maximum: 256 }
+    validates :payment_transactions, presence: true
+    validates :checksum, presence: true
+    validates_associated :payment_transactions
+    validates_associated :payer_account
+
+    after_initialize :set_defaults
+    after_initialize :validate_checksum
+
+    before_validation :create_payment_request_id
+    before_validation :refresh_checksum
+
+    def poskey=(value = nil)
+      value = ::Barion.poskey if value.nil?
+      super(value)
+    end
+
+    def payment_type=(value)
+      case value.to_sym
+      when :immediate
+        self.reservation_period = nil
+      when :reservation
+        self.reservation_period = 30.minutes.to_i
+      when :delayed_capture
+        self.reservation_period = 1.minutes.to_i
+        self.delayed_capture_period = 1.week.to_i
+      else
+        raise ArgumentError, "#{value} is not a valid payment_type"
+      end
+      super(value)
+    end
+
+    def payer_work_phone_number=(number)
+      super(::Barion::DataFormats.phone_number(number))
+    end
+
+    def payer_phone_number=(number)
+      super(::Barion::DataFormats.phone_number(number))
+    end
+
+    def payer_home_number=(number)
+      super(::Barion::DataFormats.phone_number(number))
+    end
+
+    def readonly?
+      return false if @_bypass_readonly
+
+      !initial?
+    end
+
+    def refresh_checksum
+      self.checksum = gen_checksum
+    end
+
+    def execute
+      if valid?
+        ::Barion.endpoint['v2/Payment/Start'].post(
+          as_json.to_json,
+          { content_type: :json, accept: :json }
+        ) { |response, request, _result| handle_response(response, request) }
+      else
+        false
+      end
+    end
+
+    def refresh_state
+      ::Barion.endpoint['v2/Payment/GetPaymentState'].get(
+        {
+          params: {
+            POSKey: poskey,
+            PaymentId: payment_id
+          }
+        }
+      ) { |response, request, _| handle_response(response, request) }
+    end
+
+    def serialize_options
+      { only: %i[callback_url card_holder_name_hint challenge_preference currency
+                 delayed_capture_period funding_sources guest_check_out initiate_recurrence
+                 locale order_number payer_hint payer_home_number payer_phone_number
+                 payer_work_phone_number payment_type payment_window poskey recurrence_type
+                 redirect_url reservation_period payment_request_id recurrence_id trace_id],
+        include: %i[billing_address shipping_address payment_transactions payer_account purchase_information],
+        map: {
+          keys: {
+            _all: :camelize,
+            poskey: 'POSKey',
+            payment_transactions: 'Transactions'
+          },
+          values: {
+            _all: proc { |v| v.respond_to?(:camelize) ? v.camelize : v },
+            _except: %w[poskey redirect_url callback_url locale payment_request_id payer_hint card_holder_name_hint],
+            reservation_period: :as_time,
+            delayed_capture_period: :as_time,
+            payment_window: :as_time,
+            funding_sources: :as_list,
+            challenge_preference: :as_enum_id
+          }
+        } }
+    end
+
+    def deserialize_options
+      {
+        assoc: {
+          payment_transactions: {
+            pos_transaction_id: 'POSTransactionId'
+          }
+        },
+        map: {
+          keys: {
+            _all: :underscore,
+            Transactions: 'payment_transactions',
+            CreatedAt: 'barion_created_at'
+          },
+          values: {
+            _all: proc { |v| v.respond_to?(:underscore) ? v.underscore : v },
+            _except: %w[Locale Currency]
+          }
+        },
+        before_save: :refresh_checksum
+      }
+    end
+
+    protected
+
+    # rubocop:disable Lint/UselessMethodDefinition
+    def checksum=(value)
+      super(value)
+    end
+    # rubocop:enable Lint/UselessMethodDefinition
+
+    def handle_response(response, request)
+      case response.code
+      when 200
+        process_response(JSON.parse(response))
+        refresh_checksum
+        _bypass_readonly do
+          save
+        end
+        true
+      when 301, 302, 307
+        raise ::Barion::Error.new(
+          { Title: response.description,
+            Description: 'No redirection is allowed in communication, please check endpoint!',
+            HappenedAt: DateTime.now,
+            ErrorCode: response.code,
+            EndPoint: request.url }
+        )
+      when 400
+        errors = ::JSON.parse(response)['Errors']
+        raise ::Barion::Error.new(
+          { Title: response.description,
+            Description: 'Request failed, please check errors',
+            HappenedAt: DateTime.now,
+            Errors: errors,
+            ErrorCode: response.code,
+            EndPoint: request.url }
+        )
+      end
+    end
+
+    def set_defaults
+      self.poskey = ::Barion.poskey if poskey.nil?
+      self.callback_url = ::Barion::Engine.routes.url_helpers.gateway_callback_url
+      self.redirect_url = ::Barion::Engine.routes.url_helpers.gateway_back_url
+    end
+
+    def create_payment_request_id
+      self.payment_request_id = "#{::Barion.acronym}#{::Time.now.to_f.to_s.gsub('.', '')}" if payment_request_id.nil?
+    end
+
+    def gen_checksum
+      ::Digest::SHA512.hexdigest(as_json.to_json)
+    end
+
+    def validate_checksum
+      if checksum.present? && checksum != gen_checksum
+        raise ::Barion::TamperedData, "checksum: #{refresh_checksum}, json: #{as_json}"
+      end
+
+      true
+    end
+
+    private
+
+    def _bypass_readonly
+      @_bypass_readonly = true
+      yield
+      @_bypass_readonly = false
+    end
+  end
+end