gera 0.3.4

data/app/models/gera/direction_rate_history_interval.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Gera
+  class DirectionRateHistoryInterval < ApplicationRecord
+    include HistoryIntervalConcern
+
+    # Их не надо подключать, потому что иначе при создании записи
+    # ActiveRercord проверяет есить ли они в базе
+    #
+    # belongs_to :payment_system_from, class_name: 'PaymentSystem'
+    # belongs_to :payment_system_to, class_name: 'PaymentSystem'
+
+    def self.create_by_interval!(interval_from, interval_to = nil)
+      interval_to ||= interval_from + INTERVAL
+      DirectionRate
+        .where('created_at >= ? and created_at < ?', interval_from, interval_to)
+        .group(:ps_from_id, :ps_to_id)
+        .pluck(:ps_from_id, :ps_to_id, 'min(rate_value)', 'max(rate_value)', 'min(rate_percent)', 'max(rate_percent)')
+        .each do |ps_from_id, ps_to_id, min_rate, max_rate, min_comission, max_comission|
+
+        next if ps_from_id == ps_to_id
+
+        create!(
+          payment_system_from_id: ps_from_id,
+          payment_system_to_id: ps_to_id,
+          min_rate: min_rate, max_rate: max_rate,
+          min_comission: min_comission, max_comission: max_comission,
+          interval_from: interval_from, interval_to: interval_to
+        )
+      end
+    end
+  end
+end

data/app/models/gera/direction_rate_history_interval_filter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Gera
+  class DirectionRateHistoryIntervalFilter
+    include Virtus.model strict: true
+    include ActiveModel::Conversion
+    extend  ActiveModel::Naming
+    include ActiveModel::Validations
+
+    attribute :payment_system_from_id, Integer, default: ->(_a, _b) { Gera::PaymentSystem.first.id }
+    attribute :payment_system_to_id, Integer, default: ->(_a, _b) { Gera::PaymentSystem.first.id }
+    attribute :value_type, String, default: 'rate'
+
+    def payment_system_from
+      @payment_system_from ||= Gera::PaymentSystem.find payment_system_from_id
+    end
+
+    def payment_system_to
+      @payment_system_to ||= Gera::PaymentSystem.find payment_system_to_id
+    end
+
+    def to_param
+      to_hash
+    end
+
+    def persisted?
+      false
+    end
+  end
+end

data/app/models/gera/direction_rate_snapshot.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Gera
+  class DirectionRateSnapshot < ApplicationRecord
+    has_many :direction_rates, foreign_key: :snapshot_id
+  end
+end

data/app/models/gera/exchange_rate.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# Комиссия для расчета конечного курса между платежными системами
+# TODO: Пеерименовать в Direction
+# Комиссии по направлениям платежных систем
+# если в парсере операторы изменили курс/комиссию, то эта комиссия
+# устанвливается сначала сюда, потом растекается по остальным
+#
+# * value - само значение комиссии
+# * cor1/cor2 - границы коридора
+#
+# * position - позиция в best которую нужно установить?
+# * on_notif - ???
+# * on_corridor - в коридоре?
+module Gera
+  class ExchangeRate < ApplicationRecord
+    include Authority::Abilities
+
+    DEFAULT_COMISSION = 50
+
+    include Mathematic
+    include DirectionSupport
+
+    belongs_to :payment_system_from, foreign_key: :income_payment_system_id, class_name: 'Gera::PaymentSystem'
+    belongs_to :payment_system_to, foreign_key: :outcome_payment_system_id, class_name: 'Gera::PaymentSystem'
+
+    scope :ordered, -> { order :id }
+    scope :enabled, -> { where is_enabled: true }
+
+    scope :with_payment_systems, lambda {
+      includes(:payment_system_from, :payment_system_to)
+        .joins(:payment_system_from, :payment_system_to)
+    }
+
+    scope :available, lambda {
+      with_payment_systems
+        .enabled
+        .where("#{PaymentSystem.table_name}.income_enabled and payment_system_tos_gera_exchange_rates.outcome_enabled")
+        .where("#{table_name}.income_payment_system_id <> #{table_name}.outcome_payment_system_id")
+    }
+
+    after_commit :update_direction_rates, if: -> { previous_changes.key?('value') }
+
+    before_create do
+      self.in_cur = payment_system_from.currency.to_s
+      self.out_cur = payment_system_to.currency.to_s
+      self.comission ||= DEFAULT_COMISSION
+    end
+
+    validates :commission, presence: true
+
+    delegate :rate, :currency_rate, to: :direction_rate
+
+    alias_attribute :ps_from_id, :income_payment_system_id
+    alias_attribute :ps_to_id, :outcome_payment_system_id
+    alias_attribute :payment_system_from_id, :income_payment_system_id
+    alias_attribute :payment_system_to_id, :outcome_payment_system_id
+
+    alias_attribute :comission, :value
+    alias_attribute :commission, :value
+    alias_attribute :comission_percents, :value
+
+    alias_attribute :income_payment_system, :payment_system_from
+    alias_attribute :outcome_payment_system, :payment_system_to
+
+    def self.list_rates
+      order('id asc').each_with_object({}) do |er, h|
+        h[er.income_payment_system_id] ||= {}
+        h[er.income_payment_system_id][er.outcome_payment_system_id] = h.value
+      end
+    end
+
+    def available?
+      is_enabled?
+    end
+
+    def update_finite_rate!(finite_rate)
+      update! comission: calculate_comission(finite_rate, currency_rate.rate_value)
+    end
+
+    def custom_inspect
+      {
+        value: value,
+        exchange_rate_id: id,
+        payment_system_to: payment_system_to.to_s,
+        payment_system_from: payment_system_from.to_s,
+        out_currency: out_currency.to_s,
+        in_currency: in_currency.to_s
+      }.to_s
+    end
+
+    def currency_pair
+      @currency_pair ||= CurrencyPair.new in_currency, out_currency
+    end
+
+    def out_currency
+      Money::Currency.find out_cur
+    end
+
+    def currency_to
+      out_currency
+    end
+
+    def currency_from
+      in_currency
+    end
+
+    def in_currency
+      Money::Currency.find in_cur
+    end
+
+    def finite_rate
+      direction_rate.rate
+    end
+
+    def to_s
+      [in_currency, out_currency].join '/'
+    end
+
+    def direction_rate
+      Universe.direction_rates_repository.find_direction_rate_by_exchange_rate_id id
+    end
+
+    private
+
+    def update_direction_rates
+      DirectionsRatesWorker.perform_async(exchange_rate_id: id)
+    end
+  end
+end

data/app/models/gera/external_rate.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Курсы внешних систем
+module Gera
+  class ExternalRate < ApplicationRecord
+    include CurrencyPairSupport
+
+    belongs_to :source, class_name: 'RateSource'
+    belongs_to :snapshot, class_name: 'ExternalRateSnapshot'
+
+    scope :ordered, -> { order :cur_from, :cur_to }
+
+    before_validation do
+      self.source ||= snapshot.try :rate_source
+    end
+
+    before_validation :upcase_currencies
+
+    # TODO: validate cur_from, cur_to из списка разрешенных
+
+    delegate :actual_for, to: :snapshot
+
+    def direction_rate
+      Universe.direction_rates_repository.find_direction_rate_by_exchange_rate_id id
+    end
+
+    def dump
+      as_json(only: %i[id cur_from cur_to rate_value source_id created_at])
+    end
+
+    private
+
+    def upcase_currencies
+      self.cur_from = cur_from.to_s.upcase if cur_from.present?
+      self.cur_to = cur_to.to_s.upcase if cur_to.present?
+    end
+  end
+end

data/app/models/gera/external_rate_snapshot.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Gera
+  class ExternalRateSnapshot < ApplicationRecord
+    belongs_to :rate_source
+
+    has_many :external_rates, foreign_key: :snapshot_id
+
+    scope :ordered, -> { order 'actual_for desc' }
+    scope :last_actuals_by_rate_sources, -> { where id: group(:rate_source_id).maximum(:id).values }
+
+    before_save do
+      self.actual_for ||= Time.zone.now
+    end
+
+    def to_s
+      "snapshot[#{id}]:#{rate_source}:#{actual_for}"
+    end
+  end
+end

data/app/models/gera/payment_system.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Gera
+  class PaymentSystem < ApplicationRecord
+    include ::Archivable
+    include Gera::Mathematic
+    include Authority::Abilities
+
+    scope :ordered, -> { order :priority }
+    scope :enabled, -> { where 'income_enabled>0 or outcome_enabled>0' }
+    scope :disabled, -> { where income_enabled: false, outcome_enabled: false }
+    scope :available, -> { where is_available: true }
+
+    # TODO: move to kassa-admin
+    enum total_computation_method: %i[regular_fee reverse_fee]
+    enum transfer_comission_payer: %i[user shop], _prefix: :transfer_comission_payer
+
+    validates :name, presence: true, uniqueness: true
+    validates :currency, presence: true
+
+    before_create do
+      self.priority = self.class.maximum(:priority).to_i + 1
+    end
+
+    after_create :create_exchange_rates
+
+    delegate :iso_code, to: :currency, prefix: true, allow_nil: true
+
+    alias_attribute :archived_at, :deleted_at
+    alias_attribute :enable_income, :income_enabled
+    alias_attribute :enable_outcome, :outcome_enabled
+
+    # TODO: rename type_cy to currency
+    def currency
+      return unless type_cy
+
+      @currency ||= Money::Currency.find_by_local_id(type_cy) || raise("Не найдена валюта #{type_cy}")
+    end
+
+    def currency=(cur)
+      cur = Money::Currency.find cur unless cur.is_a? Money::Currency
+      self.type_cy = cur.is_a?(Money::Currency) ? cur.local_id : nil
+    end
+
+    def to_s
+      name
+    end
+
+    # TODO: move to kassa-admin
+    def total_with_fee(money)
+      calculate_total(money: money, fee: transfer_fee)
+    end
+
+    def unverified_total_with_fee(money)
+      calculate_total(money: money, fee: unverified_transfer_fee)
+    end
+
+    private
+
+    def calculate_total(money:, fee:)
+      if fee.computation_method == 'regular_fee'
+        calculate_total_using_regular_comission(money, fee.amount)
+      elsif fee.computation_method == 'reverse_fee'
+        calculate_total_using_reverse_comission(money, fee.amount)
+      else
+        raise NotImplementedError, "Нет расчета для #{fee.computation_method}"
+      end
+    end
+
+    def transfer_fee
+      OpenStruct.new(
+        amount: income_fee,
+        computation_method: total_computation_method
+      ).freeze
+    end
+
+    def unverified_transfer_fee
+      OpenStruct.new(
+        amount: unverified_income_fee,
+        computation_method: total_computation_method
+      ).freeze
+    end
+
+    DEFAULT_COMMISSION = 10
+
+    def create_exchange_rates
+      PaymentSystem.pluck(:id).each do |foreign_id|
+        ExchangeRate
+          .create_with(commission: DEFAULT_COMMISSION)
+          .find_or_create_by(payment_system_from_id: id, payment_system_to_id: foreign_id)
+
+        ExchangeRate
+          .create_with(commission: DEFAULT_COMMISSION)
+          .find_or_create_by(payment_system_from_id: foreign_id, payment_system_to_id: id)
+      end
+    end
+  end
+end

data/app/models/gera/rate_source.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Gera
+  class RateSource < ApplicationRecord
+    include Authority::Abilities
+    extend CurrencyPairGenerator
+    RateNotFound = Class.new StandardError
+
+    has_many :snapshots, class_name: 'ExternalRateSnapshot'
+    has_many :external_rates, foreign_key: :source_id
+
+    belongs_to :actual_snapshot, class_name: 'ExternalRateSnapshot', optional: true
+
+    scope :ordered, -> { order :priority }
+    scope :enabled, -> { where is_enabled: true }
+
+    scope :enabled_for_cross_rates, -> { enabled }
+
+    validates :key, presence: true, uniqueness: true
+
+    before_create do
+      self.priority ||= RateSource.maximum(:priority).to_i + 1
+    end
+
+    before_validation do
+      self.title ||= self.class.name.underscore
+      self.key ||= self.class.name.underscore
+    end
+
+    delegate :supported_currencies, :available_pairs, to: :class
+
+    def self.supported_currencies
+      raise 'not implemented'
+    end
+
+    def self.available_pairs
+      generate_pairs_from_currencies supported_currencies
+    end
+
+    def self.get!
+      where(type: name).take!
+    end
+
+    def find_rate_by_currency_pair!(pair)
+      find_rate_by_currency_pair(pair) || raise(RateNotFound, pair)
+    end
+
+    def find_rate_by_currency_pair(pair)
+      actual_rates.find_by_currency_pair pair
+    end
+
+    def to_s
+      name
+    end
+
+    def actual_rates
+      external_rates.where(snapshot_id: actual_snapshot_id)
+    end
+
+    def to_s
+      title
+    end
+
+    def is_currency_supported?(cur)
+      cur = Money::Currency.find cur unless cur.is_a? Money::Currency
+      supported_currencies.include? cur
+    end
+
+    private
+
+    def validate_currency!(*curs)
+      curs.each do |cur|
+        raise "Источник #{self} не поддерживает валюту #{cur}" unless is_currency_supported? cur
+      end
+    end
+  end
+end

data/app/models/gera/rate_source_auto.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Gera
+  class RateSourceAuto < RateSource
+    def build_currency_rate(pair)
+      build_same(pair) ||
+        build_from_source(manual, pair) ||
+        build_from_source(cbr, pair) ||
+        build_from_source(exmo, pair) ||
+        build_cross(pair)
+    end
+
+    private
+
+    def build_from_source(source, pair, allow_inverse = true)
+      source.build_currency_rate pair, allow_inverse
+    end
+
+    def build_same(pair)
+      return unless pair.same?
+
+      CurrencyRate.new currency_pair: pair, rate_value: 1, mode: :same
+    end
+  end
+end