harpiya_core 4.3.0.alpha

data/app/models/harpiya/exchange.rb

@@ -0,0 +1,50 @@
+module Harpiya
+  class Exchange
+    class UnableToCreateShipments < StandardError; end
+
+    def initialize(order, reimbursement_objects)
+      @order = order
+      @reimbursement_objects = reimbursement_objects
+    end
+
+    def description
+      @reimbursement_objects.map do |reimbursement_object|
+        "#{reimbursement_object.variant.options_text} => #{reimbursement_object.exchange_variant.options_text}"
+      end.join(' | ')
+    end
+
+    def display_amount
+      Harpiya::Money.new @reimbursement_objects.sum(&:total)
+    end
+
+    def perform!
+      new_exchange_inventory_units = @reimbursement_objects.map(&:build_default_exchange_inventory_unit)
+      shipments = Harpiya::Stock::Coordinator.new(@order, new_exchange_inventory_units).shipments
+      shipments_units = shipments.flat_map(&:inventory_units)
+
+      if shipments_units.sum(&:quantity) != new_exchange_inventory_units.sum(&:quantity)
+        raise UnableToCreateShipments, 'Could not generate shipments for all items. Out of stock?'
+      end
+
+      @order.shipments += shipments
+      @order.save!
+
+      shipments.each do |shipment|
+        shipment.update!(@order)
+        shipment.finalize!
+      end
+    end
+
+    def to_key
+      nil
+    end
+
+    def self.param_key
+      'harpiya_exchange'
+    end
+
+    def self.model_name
+      Harpiya::Exchange
+    end
+  end
+end

data/app/models/harpiya/fulfilment_changer.rb

@@ -0,0 +1,159 @@
+module Harpiya
+  class FulfilmentChanger
+    include ActiveModel::Validations
+
+    validates :quantity, numericality: { greater_than: 0 }
+    validates :desired_stock_location, presence: true
+    validate  :current_shipment_not_already_shipped
+    validate  :desired_shipment_different_from_current
+    validate  :enough_stock_at_desired_location, if: :handle_stock_counts?
+
+    def initialize(params = {})
+      @current_stock_location = params[:current_stock_location]
+      @desired_stock_location = params[:desired_stock_location]
+      @current_shipment       = params[:current_shipment]
+      @desired_shipment       = params[:desired_shipment]
+      @variant                = params[:variant]
+      @quantity               = params[:quantity]
+      @available_quantity     = [
+        desired_stock_location.try(:count_on_hand, variant).to_i,
+        current_quantity
+      ].max
+    end
+
+    def run!
+      return false if invalid?
+
+      desired_shipment.save! if desired_shipment.new_record?
+
+      handle_stock
+      reload_shipment_inventory_units
+      after_process_shipments
+
+      true
+    end
+
+    private
+
+    attr_reader :variant, :quantity, :current_stock_location, :desired_stock_location,
+                :current_shipment, :desired_shipment, :available_quantity
+
+    def handle_stock
+      ActiveRecord::Base.transaction do
+        if handle_stock_counts?
+          current_stock_location.restock(variant, current_on_hand_quantity, current_shipment)
+          desired_stock_location.unstock(variant, unstock_quantity, desired_shipment)
+        end
+
+        move_inventory_units_between_shipments
+      end
+    end
+
+    def move_inventory_units_between_shipments
+      update_desired_shipment_inventory_units
+      update_current_shipment_inventory_units
+    end
+
+    def current_shipment_units
+      @current_shipment_units ||= current_shipment.inventory_units.on_hand_or_backordered.where(variant_id: variant.id)
+    end
+
+    def update_desired_shipment_inventory_units
+      on_hand_unit = get_desired_shipment_inventory_unit(:on_hand)
+      on_hand_unit.update(quantity: on_hand_unit.quantity + new_on_hand_quantity)
+
+      new_backorder_quantity = current_on_hand_quantity - new_on_hand_quantity
+      if new_backorder_quantity > 0
+        backordered_unit = get_desired_shipment_inventory_unit(:backordered)
+        backordered_unit.update(quantity: backordered_unit.quantity + new_backorder_quantity)
+      end
+    end
+
+    def update_current_shipment_inventory_units
+      reduced_quantity = current_on_hand_quantity
+
+      # Reduce quantities from all backordered units first in case there is more than one.
+      backorder_units = current_shipment_units.backordered
+      reduced_quantity = reduce_units_quantities(reduced_quantity, backorder_units) if backorder_units.any?
+
+      # Reduce quantities from all on_hand units in case there is more than one.
+      if reduced_quantity > 0
+        on_hand_units = current_shipment_units.on_hand
+        reduce_units_quantities(reduced_quantity, on_hand_units) if on_hand_units.any?
+      end
+    end
+
+    def reduce_units_quantities(reduced_quantity, units)
+      units.each do |unit|
+        unit.quantity > reduced_quantity ? unit.update(quantity: unit.quantity - reduced_quantity) : unit.destroy!
+        reduced_quantity -= unit.quantity
+      end
+      reduced_quantity
+    end
+
+    def get_desired_shipment_inventory_unit(state)
+      desired_shipment.inventory_units.find_or_create_by(state: state) do |unit|
+        current_shipment_unit = current_shipment_units.first
+        unit.variant_id = current_shipment_unit.variant_id
+        unit.order_id = current_shipment_unit.order_id
+        unit.line_item_id = current_shipment_unit.line_item_id
+        unit.quantity = 0
+      end
+    end
+
+    def after_process_shipments
+      if current_shipment.inventory_units.sum(:quantity).zero?
+        current_shipment.destroy!
+      else
+        current_shipment.refresh_rates
+      end
+
+      desired_shipment.refresh_rates
+
+      desired_shipment.order.reload
+      desired_shipment.order.update_with_updater!
+    end
+
+    def new_on_hand_quantity
+      [available_quantity, current_on_hand_quantity].min
+    end
+
+    def unstock_quantity
+      desired_stock_location.backorderable?(variant) ? quantity : new_on_hand_quantity
+    end
+
+    def current_on_hand_quantity
+      [current_shipment.inventory_units.on_hand_or_backordered.sum(:quantity), quantity].min
+    end
+
+    def reload_shipment_inventory_units
+      [current_shipment, desired_shipment].each { |shipment| shipment.inventory_units.reload }
+    end
+
+    def current_quantity
+      desired_stock_location == current_stock_location ? quantity : 0
+    end
+
+    def handle_stock_counts?
+      current_shipment.order.completed? && current_stock_location != desired_stock_location
+    end
+
+    def current_shipment_not_already_shipped
+      return unless current_shipment.shipped?
+
+      errors.add(:current_shipment, :has_already_been_shipped)
+    end
+
+    def enough_stock_at_desired_location
+      return if Harpiya::Stock::Quantifier.new(variant, desired_stock_location).can_supply?(quantity)
+
+      errors.add(:desired_shipment, :has_not_enough_stock_at_desired_location)
+    end
+
+    def desired_shipment_different_from_current
+      return unless desired_shipment.id == current_shipment.id
+
+      errors.add(:desired_shipment, :can_not_transfer_within_same_shipment)
+    end
+  end
+end

data/app/models/harpiya/gateway.rb

@@ -0,0 +1,81 @@
+module Harpiya
+  class Gateway < PaymentMethod
+    FROM_DOLLAR_TO_CENT_RATE = 100.0
+
+    delegate :authorize, :purchase, :capture, :void, :credit, to: :provider
+
+    validates :type, presence: true
+
+    preference :server, :string, default: 'test'
+    preference :test_mode, :boolean, default: true
+
+    def payment_source_class
+      CreditCard
+    end
+
+    def provider
+      gateway_options = options
+      gateway_options.delete :login if gateway_options.key?(:login) && gateway_options[:login].nil?
+      if gateway_options[:server]
+        ActiveMerchant::Billing::Base.mode = gateway_options[:server].to_sym
+      end
+      @provider ||= provider_class.new(gateway_options)
+    end
+
+    def options
+      preferences.each_with_object({}) { |(key, value), memo| memo[key.to_sym] = value; }
+    end
+
+    def method_missing(method, *args)
+      if @provider.nil? || !@provider.respond_to?(method)
+        super
+      else
+        provider.send(method, *args)
+      end
+    end
+
+    def payment_profiles_supported?
+      false
+    end
+
+    def method_type
+      'gateway'
+    end
+
+    def exchange_multiplier
+      FROM_DOLLAR_TO_CENT_RATE
+    end
+
+    def supports?(source)
+      return true unless provider_class.respond_to? :supports?
+      return false unless source.brand
+
+      provider_class.supports?(source.brand)
+    end
+
+    def disable_customer_profile(source)
+      if source.is_a? CreditCard
+        source.update_column :gateway_customer_profile_id, nil
+      else
+        raise 'You must implement disable_customer_profile method for this gateway.'
+      end
+    end
+
+    def sources_by_order(order)
+      source_ids = order.payments.where(source_type: payment_source_class.to_s, payment_method_id: id).pluck(:source_id).uniq
+      payment_source_class.where(id: source_ids).with_payment_profile
+    end
+
+    def reusable_sources(order)
+      if order.completed?
+        sources_by_order order
+      else
+        if order.user_id
+          credit_cards.where(user_id: order.user_id).with_payment_profile
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/app/models/harpiya/gateway/bogus.rb

@@ -0,0 +1,92 @@
+module Harpiya
+  class Gateway::Bogus < Gateway
+    TEST_VISA = ['4111111111111111', '4012888888881881', '4222222222222']
+    TEST_MC   = ['5500000000000004', '5555555555554444', '5105105105105100', '2223000010309703']
+    TEST_AMEX = ['378282246310005', '371449635398431', '378734493671000', '340000000000009']
+    TEST_DISC = ['6011000000000004', '6011111111111117', '6011000990139424']
+
+    VALID_CCS = ['1', TEST_VISA, TEST_MC, TEST_AMEX, TEST_DISC].flatten
+
+    attr_accessor :test
+
+    def provider_class
+      self.class
+    end
+
+    def preferences
+      {}
+    end
+
+    def create_profile(payment)
+      return if payment.source.has_payment_profile?
+
+      # simulate the storage of credit card profile using remote service
+      if success = VALID_CCS.include?(payment.source.number)
+        payment.source.update(gateway_customer_profile_id: generate_profile_id(success))
+      end
+    end
+
+    def authorize(_money, credit_card, _options = {})
+      profile_id = credit_card.gateway_customer_profile_id
+      if VALID_CCS.include?(credit_card.number) || (profile_id&.starts_with?('BGS-'))
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'D' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
+      end
+    end
+
+    def purchase(_money, credit_card, _options = {})
+      profile_id = credit_card.gateway_customer_profile_id
+      if VALID_CCS.include?(credit_card.number) || (profile_id&.starts_with?('BGS-'))
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'M' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
+      end
+    end
+
+    def credit(_money, _credit_card, _response_code, _options = {})
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
+    end
+
+    def capture(_money, authorization, _gateway_options)
+      if authorization == '12345'
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true)
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', error: 'Bogus Gateway: Forced failure', test: true)
+      end
+    end
+
+    def void(_response_code, _credit_card, _options = {})
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
+    end
+
+    def cancel(_response_code)
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
+    end
+
+    def test?
+      # Test mode is not really relevant with bogus gateway (no such thing as live server)
+      true
+    end
+
+    def payment_profiles_supported?
+      true
+    end
+
+    def actions
+      %w(capture void credit)
+    end
+
+    private
+
+    def generate_profile_id(success)
+      record = true
+      prefix = success ? 'BGS' : 'FAIL'
+      while record
+        random = "#{prefix}-#{Array.new(6) { rand(6) }.join}"
+        record = CreditCard.find_by(gateway_customer_profile_id: random)
+      end
+      random
+    end
+  end
+end

data/app/models/harpiya/gateway/bogus_simple.rb

@@ -0,0 +1,24 @@
+# Bogus Gateway that doesn't support payment profiles
+module Harpiya
+  class Gateway::BogusSimple < Gateway::Bogus
+    def payment_profiles_supported?
+      false
+    end
+
+    def authorize(_money, credit_card, _options = {})
+      if VALID_CCS.include? credit_card.number
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
+      end
+    end
+
+    def purchase(_money, credit_card, _options = {})
+      if VALID_CCS.include? credit_card.number
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
+      end
+    end
+  end
+end

data/app/models/harpiya/icon.rb

@@ -0,0 +1,9 @@
+module Harpiya
+  class Icon < Harpiya::Asset
+    has_one_attached :attachment
+
+    ICON_TYPES = %i[png jpg jpeg gif svg]
+
+    validates :attachment, attached: true, content_type: ICON_TYPES
+  end
+end

data/app/models/harpiya/image.rb

@@ -0,0 +1,74 @@
+module Harpiya
+  class Image < Asset
+    include Configuration::ActiveStorage
+    include Rails.application.routes.url_helpers
+
+    # In Rails 5.x class constants are being undefined/redefined during the code reloading process
+    # in a rails development environment, after which the actual ruby objects stored in those class constants
+    # are no longer equal (subclass == self) what causes error ActiveRecord::SubclassNotFound
+    # Invalid single-table inheritance type: Harpiya::Image is not a subclass of Harpiya::Image.
+    # The line below prevents the error.
+    self.inheritance_column = nil
+
+    def styles
+      self.class.styles.map do |_, size|
+        width, height = size.chop.split('x')
+
+        {
+          url: polymorphic_path(attachment.variant(
+                                  gravity: 'center',
+                                  resize: size,
+                                  extent: size,
+                                  background: 'snow2',
+                                  quality: 80
+                                ), only_path: true),
+          width: width,
+          height: height
+        }
+      end
+    end
+
+    def style(name)
+      size = self.class.styles[name]
+      return unless size
+
+      width, height = size.chop.split('x')
+
+      {
+        url: polymorphic_path(attachment.variant(
+                                gravity: 'center',
+                                resize: size,
+                                extent: size,
+                                background: 'snow2',
+                                quality: 80
+                              ), only_path: true),
+        size: size,
+        width: width,
+        height: height
+      }
+    end
+
+    def style_dimensions(name)
+      size = self.class.styles[name]
+      width, height = size.chop.split('x')
+
+      {
+        width: width,
+        height: height
+      }
+    end
+
+    def plp_url
+      size = self.class.styles[:plp_and_carousel]
+      variant = attachment.variant(
+        gravity: 'center',
+        resize: size,
+        extent: size,
+        background: 'snow2',
+        quality: 80
+      )
+
+      polymorphic_path(variant, only_path: true)
+    end
+  end
+end