harpiya_core 4.3.0.alpha

data/app/models/harpiya/store_credit_event.rb

@@ -0,0 +1,38 @@
+module Harpiya
+  class StoreCreditEvent < Harpiya::Base
+    acts_as_paranoid
+
+    belongs_to :store_credit
+    belongs_to :originator, polymorphic: true
+
+    scope :exposed_events, -> { where.not(action: [Harpiya::StoreCredit::ELIGIBLE_ACTION, Harpiya::StoreCredit::AUTHORIZE_ACTION]) }
+    scope :reverse_chronological, -> { order(created_at: :desc) }
+
+    delegate :currency, to: :store_credit
+
+    def display_amount
+      Harpiya::Money.new(amount, currency: currency)
+    end
+
+    def display_user_total_amount
+      Harpiya::Money.new(user_total_amount, currency: currency)
+    end
+
+    def display_action
+      case action
+      when Harpiya::StoreCredit::CAPTURE_ACTION
+        Harpiya.t('store_credit.captured')
+      when Harpiya::StoreCredit::AUTHORIZE_ACTION
+        Harpiya.t('store_credit.authorized')
+      when Harpiya::StoreCredit::ALLOCATION_ACTION
+        Harpiya.t('store_credit.allocated')
+      when Harpiya::StoreCredit::VOID_ACTION, Harpiya::StoreCredit::CREDIT_ACTION
+        Harpiya.t('store_credit.credit')
+      end
+    end
+
+    def order
+      Harpiya::Payment.find_by(response_code: authorization_code).try(:order)
+    end
+  end
+end

data/app/models/harpiya/store_credit_type.rb

@@ -0,0 +1,6 @@
+module Harpiya
+  class StoreCreditType < Harpiya::Base
+    DEFAULT_TYPE_NAME = 'Expiring'.freeze
+    has_many :store_credits, class_name: 'Harpiya::StoreCredit', foreign_key: 'type_id'
+  end
+end

data/app/models/harpiya/store_product.rb

@@ -0,0 +1,11 @@
+module Harpiya
+  class StoreProduct < Harpiya::Base
+    self.table_name = 'harpiya_products_stores'
+
+    belongs_to :store, class_name: 'Harpiya::Store', touch: true
+    belongs_to :product, class_name: 'Harpiya::Product', touch: true
+
+    validates :store, :product, presence: true
+    validates :store_id, uniqueness: { scope: :product_id }
+  end
+end

data/app/models/harpiya/tax_category.rb

@@ -0,0 +1,18 @@
+module Harpiya
+  class TaxCategory < Harpiya::Base
+    acts_as_paranoid
+    validates :name, presence: true, uniqueness: { case_sensitive: false, scope: :deleted_at }
+
+    has_many :tax_rates, dependent: :destroy, inverse_of: :tax_category
+
+    before_save :set_default_category
+
+    def set_default_category
+      # set existing default tax category to false if this one has been marked as default
+
+      if is_default && tax_category = self.class.where(is_default: true).where.not(id: id).first
+        tax_category.update_columns(is_default: false, updated_at: Time.current)
+      end
+    end
+  end
+end

data/app/models/harpiya/tax_rate.rb

@@ -0,0 +1,119 @@
+module Harpiya
+  class TaxRate < Harpiya::Base
+    acts_as_paranoid
+
+    include Harpiya::CalculatedAdjustments
+    include Harpiya::AdjustmentSource
+
+    with_options inverse_of: :tax_rates do
+      belongs_to :zone, class_name: 'Harpiya::Zone', optional: true
+      belongs_to :tax_category,
+                 class_name: 'Harpiya::TaxCategory'
+    end
+
+    with_options presence: true do
+      validates :amount, numericality: { allow_nil: true }
+      validates :tax_category
+    end
+
+    scope :by_zone, ->(zone) { where(zone_id: zone.id) }
+    scope :potential_rates_for_zone,
+          ->(zone) do
+            where(zone_id: Harpiya::Zone.potential_matching_zones(zone).pluck(:id))
+          end
+    scope :for_default_zone,
+          -> { potential_rates_for_zone(Harpiya::Zone.default_tax) }
+    scope :for_tax_category,
+          ->(category) { where(tax_category_id: category.try(:id)) }
+    scope :included_in_price, -> { where(included_in_price: true) }
+
+    # Gets the array of TaxRates appropriate for the specified tax zone
+    def self.match(order_tax_zone)
+      return [] unless order_tax_zone
+
+      potential_rates_for_zone(order_tax_zone)
+    end
+
+    # Pre-tax amounts must be stored so that we can calculate
+    # correct rate amounts in the future. For example:
+    # https://github.com/harpiya/harpiya/issues/4318#issuecomment-34723428
+    def self.store_pre_tax_amount(item, rates)
+      pre_tax_amount = case item.class.to_s
+                       when 'Harpiya::LineItem' then item.discounted_amount
+                       when 'Harpiya::Shipment' then item.discounted_cost
+                       end
+
+      included_rates = rates.select(&:included_in_price)
+      if included_rates.any?
+        pre_tax_amount /= (1 + included_rates.sum(&:amount))
+      end
+
+      item.update_column(:pre_tax_amount, pre_tax_amount)
+    end
+
+    # Deletes all tax adjustments, then applies all applicable rates
+    # to relevant items.
+    def self.adjust(order, items)
+      rates = match(order.tax_zone)
+      tax_categories = rates.map(&:tax_category)
+
+      # using destroy_all to ensure adjustment destroy callback fires.
+      Harpiya::Adjustment.where(adjustable: items).tax.destroy_all
+
+      relevant_items = items.select do |item|
+        tax_categories.include?(item.tax_category)
+      end
+
+      relevant_items.each do |item|
+        relevant_rates = rates.select do |rate|
+          rate.tax_category == item.tax_category
+        end
+        store_pre_tax_amount(item, relevant_rates)
+        relevant_rates.each do |rate|
+          rate.adjust(order, item)
+        end
+      end
+
+      # updates pre_tax for items without any tax rates
+      remaining_items = items - relevant_items
+      remaining_items.each do |item|
+        store_pre_tax_amount(item, [])
+      end
+    end
+
+    def self.included_tax_amount_for(options)
+      return 0 unless options[:tax_zone] && options[:tax_category]
+
+      potential_rates_for_zone(options[:tax_zone]).
+        included_in_price.
+        for_tax_category(options[:tax_category]).
+        sum(:amount)
+    end
+
+    def adjust(order, item)
+      create_adjustment(order, item, included_in_price)
+    end
+
+    def compute_amount(item)
+      compute(item)
+    end
+
+    private
+
+    def label
+      Harpiya.t included_in_price? ? :including_tax : :excluding_tax,
+              scope: 'adjustment_labels.tax_rates',
+              name: name.presence || tax_category.name,
+              amount: amount_for_label
+    end
+
+    def amount_for_label
+      return '' unless show_rate_in_label?
+
+      ' ' + ActiveSupport::NumberHelper::NumberToPercentageConverter.convert(
+        amount * 100,
+        locale: I18n.locale
+      )
+    end
+  end
+end

data/app/models/harpiya/taxon.rb

@@ -0,0 +1,110 @@
+# TODO: let friendly id take care of sanitizing the url
+require 'stringex'
+
+module Harpiya
+  class Taxon < Harpiya::Base
+    extend FriendlyId
+    friendly_id :permalink, slug_column: :permalink, use: :history
+    before_validation :set_permalink, on: :create, if: :name
+
+    acts_as_nested_set dependent: :destroy
+
+    belongs_to :taxonomy, class_name: 'Harpiya::Taxonomy', inverse_of: :taxons
+    has_many :classifications, -> { order(:position) }, dependent: :delete_all, inverse_of: :taxon
+    has_many :products, through: :classifications
+
+    has_many :menu_items, as: :linked_resource
+
+    has_many :prototype_taxons, class_name: 'Harpiya::PrototypeTaxon', dependent: :destroy
+    has_many :prototypes, through: :prototype_taxons, class_name: 'Harpiya::Prototype'
+
+    has_many :promotion_rule_taxons, class_name: 'Harpiya::PromotionRuleTaxon', dependent: :destroy
+    has_many :promotion_rules, through: :promotion_rule_taxons, class_name: 'Harpiya::PromotionRule'
+
+    validates :name, presence: true, uniqueness: { scope: [:parent_id, :taxonomy_id], allow_blank: true, case_sensitive: false }
+    validates :permalink, uniqueness: { case_sensitive: false }
+    validates :hide_from_nav, inclusion: { in: [true, false] }
+    validates_associated :icon
+    validate :check_for_root, on: :create
+    with_options length: { maximum: 255 }, allow_blank: true do
+      validates :meta_keywords
+      validates :meta_description
+      validates :meta_title
+    end
+
+    after_save :touch_ancestors_and_taxonomy
+    after_touch :touch_ancestors_and_taxonomy
+
+    has_one :icon, as: :viewable, dependent: :destroy, class_name: 'Harpiya::TaxonImage'
+
+    self.whitelisted_ransackable_associations = %w[taxonomy]
+
+    # indicate which filters should be used for a taxon
+    # this method should be customized to your own site
+    def applicable_filters
+      fs = []
+      # fs << ProductFilters.taxons_below(self)
+      ## unless it's a root taxon? left open for demo purposes
+
+      fs << Harpiya::Core::ProductFilters.price_filter if Harpiya::Core::ProductFilters.respond_to?(:price_filter)
+      fs << Harpiya::Core::ProductFilters.brand_filter if Harpiya::Core::ProductFilters.respond_to?(:brand_filter)
+      fs
+    end
+
+    # Return meta_title if set otherwise generates from taxon name
+    def seo_title
+      meta_title.blank? ? name : meta_title
+    end
+
+    # Creates permalink base for friendly_id
+    def set_permalink
+      if parent.present?
+        self.permalink = [parent.permalink, (permalink.blank? ? name.to_url : permalink.split('/').last)].join('/')
+      else
+        self.permalink = name.to_url if permalink.blank?
+      end
+    end
+
+    def active_products
+      products.active
+    end
+
+    def pretty_name
+      ancestor_chain = ancestors.inject('') do |name, ancestor|
+        name += "#{ancestor.name} -> "
+      end
+      ancestor_chain + name.to_s
+    end
+
+    def cached_self_and_descendants_ids
+      Rails.cache.fetch("#{cache_key_with_version}/descendant-ids") do
+        self_and_descendants.ids
+      end
+    end
+
+    # awesome_nested_set sorts by :lft and :rgt. This call re-inserts the child
+    # node so that its resulting position matches the observable 0-indexed position.
+    # ** Note ** no :position column needed - a_n_s doesn't handle the reordering if
+    #  you bring your own :order_column.
+    #
+    #  See #3390 for background.
+    def child_index=(idx)
+      move_to_child_with_index(parent, idx.to_i) unless new_record?
+    end
+
+    private
+
+    def touch_ancestors_and_taxonomy
+      # Touches all ancestors at once to avoid recursive taxonomy touch, and reduce queries.
+      ancestors.update_all(updated_at: Time.current)
+      # Have taxonomy touch happen in #touch_ancestors_and_taxonomy rather than association option in order for imports to override.
+      taxonomy.try!(:touch)
+    end
+
+    def check_for_root
+      if taxonomy.try(:root).present? && parent_id.nil?
+        errors.add(:root_conflict, 'this taxonomy already has a root taxon')
+      end
+    end
+  end
+end

data/app/models/harpiya/taxon_image.rb

@@ -0,0 +1,18 @@
+module Harpiya
+  class TaxonImage < Asset
+    include Configuration::ActiveStorage
+    include Rails.application.routes.url_helpers
+
+    def styles
+      self.class.styles.map do |_, size|
+        width, height = size[/(\d+)x(\d+)/].split('x')
+
+        {
+          url: polymorphic_path(attachment.variant(resize: size), only_path: true),
+          width: width,
+          height: height
+        }
+      end
+    end
+  end
+end

data/app/models/harpiya/taxon_image/configuration/active_storage.rb

@@ -0,0 +1,36 @@
+module Harpiya
+  class TaxonImage < Asset
+    module Configuration
+      module ActiveStorage
+        extend ActiveSupport::Concern
+
+        included do
+          validate :check_attachment_content_type
+
+          has_one_attached :attachment
+
+          def self.styles
+            @styles ||= {
+              mini: '32x32>',
+              normal: '128x128>'
+            }
+          end
+
+          def default_style
+            :mini
+          end
+
+          def accepted_image_types
+            %w(image/jpeg image/jpg image/png image/gif)
+          end
+
+          def check_attachment_content_type
+            if attachment.attached? && !attachment.content_type.in?(accepted_image_types)
+              errors.add(:attachment, :not_allowed_content_type)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/harpiya/taxonomy.rb

@@ -0,0 +1,25 @@
+module Harpiya
+  class Taxonomy < Harpiya::Base
+    acts_as_list
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+
+    has_many :taxons, inverse_of: :taxonomy
+    has_one :root, -> { where parent_id: nil }, class_name: 'Harpiya::Taxon', dependent: :destroy
+
+    after_create :set_root
+    after_save :set_root_taxon_name
+
+    default_scope { order("#{table_name}.position, #{table_name}.created_at") }
+
+    private
+
+    def set_root
+      self.root ||= Taxon.create!(taxonomy_id: id, name: name)
+    end
+
+    def set_root_taxon_name
+      root.update(name: name)
+    end
+  end
+end

data/app/models/harpiya/variant.rb

@@ -0,0 +1,347 @@
+module Harpiya
+  class Variant < Harpiya::Base
+    acts_as_paranoid
+    acts_as_list scope: :product
+
+    belongs_to :product, -> { with_deleted }, touch: true, class_name: 'Harpiya::Product', inverse_of: :variants
+    belongs_to :tax_category, class_name: 'Harpiya::TaxCategory', optional: true
+
+    delegate :name, :name=, :description, :slug, :available_on, :shipping_category_id,
+             :meta_description, :meta_keywords, :shipping_category, to: :product
+
+    # we need to have this callback before any dependent: :destroy associations
+    # https://github.com/rails/rails/issues/3458
+    before_destroy :ensure_no_line_items
+
+    # must include this after ensure_no_line_items to make sure price won't be deleted before validation
+    include Harpiya::DefaultPrice
+
+    with_options inverse_of: :variant do
+      has_many :inventory_units
+      has_many :line_items
+      has_many :stock_items, dependent: :destroy
+    end
+
+    has_many :orders, through: :line_items
+    with_options through: :stock_items do
+      has_many :stock_locations
+      has_many :stock_movements
+    end
+
+    has_many :option_value_variants, class_name: 'Harpiya::OptionValueVariant'
+    has_many :option_values, through: :option_value_variants, dependent: :destroy, class_name: 'Harpiya::OptionValue'
+
+    has_many :images, -> { order(:position) }, as: :viewable, dependent: :destroy, class_name: 'Harpiya::Image'
+
+    has_many :prices,
+             class_name: 'Harpiya::Price',
+             dependent: :destroy,
+             inverse_of: :variant
+
+    before_validation :set_cost_currency
+
+    validate :check_price
+
+    validates :option_values, presence: true, unless: :is_master?
+
+    with_options numericality: { greater_than_or_equal_to: 0, allow_nil: true } do
+      validates :cost_price
+      validates :price
+    end
+    validates :sku, uniqueness: { conditions: -> { where(deleted_at: nil) }, case_sensitive: false },
+                    allow_blank: true, unless: :disable_sku_validation?
+
+    after_create :create_stock_items
+    after_create :set_master_out_of_stock, unless: :is_master?
+
+    after_touch :clear_in_stock_cache
+
+    scope :in_stock, -> { joins(:stock_items).where('count_on_hand > ? OR track_inventory = ?', 0, false) }
+    scope :backorderable, -> { joins(:stock_items).where(harpiya_stock_items: { backorderable: true }) }
+    scope :in_stock_or_backorderable, -> { in_stock.or(backorderable) }
+
+    scope :eligible, -> {
+      where(is_master: false).or(
+        where(
+          <<-SQL
+            #{Variant.quoted_table_name}.id IN (
+              SELECT MIN(#{Variant.quoted_table_name}.id) FROM #{Variant.quoted_table_name}
+              GROUP BY #{Variant.quoted_table_name}.product_id
+              HAVING COUNT(*) = 1
+            )
+          SQL
+        )
+      )
+    }
+
+    scope :not_discontinued, -> do
+      where(
+        arel_table[:discontinue_on].eq(nil).or(
+          arel_table[:discontinue_on].gteq(Time.current)
+        )
+      )
+    end
+
+    scope :not_deleted, -> { where("#{Harpiya::Variant.quoted_table_name}.deleted_at IS NULL") }
+
+    scope :for_currency_and_available_price_amount, ->(currency = nil) do
+      currency ||= Harpiya::Config[:currency]
+      joins(:prices).where('harpiya_prices.currency = ?', currency).where('harpiya_prices.amount IS NOT NULL').distinct
+    end
+
+    scope :active, ->(currency = nil) do
+      not_discontinued.not_deleted.
+        for_currency_and_available_price_amount(currency)
+    end
+    LOCALIZED_NUMBERS = %w(cost_price weight depth width height)
+
+    LOCALIZED_NUMBERS.each do |m|
+      define_method("#{m}=") do |argument|
+        self[m] = Harpiya::LocalizedNumber.parse(argument) if argument.present?
+      end
+    end
+
+    self.whitelisted_ransackable_associations = %w[option_values product prices default_price]
+    self.whitelisted_ransackable_attributes = %w[weight sku]
+    self.whitelisted_ransackable_scopes = %i(product_name_or_sku_cont search_by_product_name_or_sku)
+
+    def self.product_name_or_sku_cont(query)
+      joins(:product).where("LOWER(#{Product.table_name}.name) LIKE LOWER(:query) OR LOWER(sku) LIKE LOWER(:query)", query: "%#{query}%")
+    end
+
+    def self.search_by_product_name_or_sku(query)
+      if defined?(HarpiyaGlobalize)
+        joins(product: :translations).where("LOWER(#{Product::Translation.table_name}.name) LIKE LOWER(:query) OR LOWER(sku) LIKE LOWER(:query)",
+                                            query: "%#{query}%")
+      else
+        product_name_or_sku_cont(query)
+      end
+    end
+
+    def available?
+      !discontinued? && product.available?
+    end
+
+    def tax_category
+      @tax_category ||= if self[:tax_category_id].nil?
+                          product.tax_category
+                        else
+                          Harpiya::TaxCategory.find(self[:tax_category_id])
+                        end
+    end
+
+    def options_text
+      @options_text ||= Harpiya::Variants::OptionsPresenter.new(self).to_sentence
+    end
+
+    # Default to master name
+    def exchange_name
+      is_master? ? name : options_text
+    end
+
+    def descriptive_name
+      is_master? ? name + ' - Master' : name + ' - ' + options_text
+    end
+
+    # use deleted? rather than checking the attribute directly. this
+    # allows extensions to override deleted? if they want to provide
+    # their own definition.
+    def deleted?
+      !!deleted_at
+    end
+
+    def options=(options = {})
+      options.each do |option|
+        set_option_value(option[:name], option[:value])
+      end
+    end
+
+    def set_option_value(opt_name, opt_value)
+      # no option values on master
+      return if is_master
+
+      option_type = Harpiya::OptionType.where(name: opt_name).first_or_initialize do |o|
+        o.presentation = opt_name
+        o.save!
+      end
+
+      current_value = option_values.detect { |o| o.option_type.name == opt_name }
+
+      if current_value.nil?
+        # then we have to check to make sure that the product has the option type
+        unless product.option_types.include? option_type
+          product.option_types << option_type
+        end
+      else
+        return if current_value.name == opt_value
+
+        option_values.delete(current_value)
+      end
+
+      option_value = Harpiya::OptionValue.where(option_type_id: option_type.id, name: opt_value).first_or_initialize do |o|
+        o.presentation = opt_value
+        o.save!
+      end
+
+      option_values << option_value
+      save
+    end
+
+    def option_value(opt_name)
+      option_values.detect { |o| o.option_type.name == opt_name }.try(:presentation)
+    end
+
+    def price_in(currency)
+      prices.detect { |price| price.currency == currency&.upcase } || prices.build(currency: currency&.upcase)
+    end
+
+    def amount_in(currency)
+      price_in(currency).try(:amount)
+    end
+
+    def compare_at_amount_in(currency)
+      price_in(currency).try(:compare_at_amount)
+    end
+
+    def price_modifier_amount_in(currency, options = {})
+      return 0 unless options.present?
+
+      options.keys.map do |key|
+        m = "#{key}_price_modifier_amount_in".to_sym
+        if respond_to? m
+          send(m, currency, options[key])
+        else
+          0
+        end
+      end.sum
+    end
+
+    def price_modifier_amount(options = {})
+      return 0 unless options.present?
+
+      options.keys.map do |key|
+        m = "#{key}_price_modifier_amount".to_sym
+        if respond_to? m
+          send(m, options[key])
+        else
+          0
+        end
+      end.sum
+    end
+
+    def compare_at_price
+      @compare_at_price ||= price_in(cost_currency).try(:compare_at_amount)
+    end
+
+    def name_and_sku
+      "#{name} - #{sku}"
+    end
+
+    def sku_and_options_text
+      "#{sku} #{options_text}".strip
+    end
+
+    def in_stock?
+      # Issue 10280
+      # Check if model responds to cache version and fall back to updated_at for older rails versions
+      # This makes sure a version is supplied when recyclable cache keys are disabled.
+      version = respond_to?(:cache_version) ? cache_version : updated_at.to_i
+      Rails.cache.fetch(in_stock_cache_key, version: version) do
+        total_on_hand > 0
+      end
+    end
+
+    delegate :total_on_hand, :can_supply?, :backorderable?, to: :quantifier
+
+    alias is_backorderable? backorderable?
+
+    def purchasable?
+      in_stock? || backorderable?
+    end
+
+    # Shortcut method to determine if inventory tracking is enabled for this variant
+    # This considers both variant tracking flag and site-wide inventory tracking settings
+    def should_track_inventory?
+      track_inventory? && Harpiya::Config.track_inventory_levels
+    end
+
+    def track_inventory
+      should_track_inventory?
+    end
+
+    def volume
+      (width || 0) * (height || 0) * (depth || 0)
+    end
+
+    def dimension
+      (width || 0) + (height || 0) + (depth || 0)
+    end
+
+    def discontinue!
+      update_attribute(:discontinue_on, Time.current)
+    end
+
+    def discontinued?
+      !!discontinue_on && discontinue_on <= Time.current
+    end
+
+    def backordered?
+      total_on_hand <= 0 && stock_items.exists?(backorderable: true)
+    end
+
+    private
+
+    def ensure_no_line_items
+      if line_items.any?
+        errors.add(:base, :cannot_destroy_if_attached_to_line_items)
+        throw(:abort)
+      end
+    end
+
+    def quantifier
+      Harpiya::Stock::Quantifier.new(self)
+    end
+
+    def set_master_out_of_stock
+      if product.master&.in_stock?
+        product.master.stock_items.update_all(backorderable: false)
+        product.master.stock_items.each(&:reduce_count_on_hand_to_zero)
+      end
+    end
+
+    # Ensures a new variant takes the product master price when price is not supplied
+    def check_price
+      if price.nil? && Harpiya::Config[:require_master_price]
+        return errors.add(:base, :no_master_variant_found_to_infer_price)  unless product&.master
+        return errors.add(:base, :must_supply_price_for_variant_or_master) if self == product.master
+
+        self.price = product.master.price
+      end
+      if price.present? && currency.nil?
+        self.currency = Harpiya::Config[:currency]
+      end
+    end
+
+    def set_cost_currency
+      self.cost_currency = Harpiya::Config[:currency] if cost_currency.blank?
+    end
+
+    def create_stock_items
+      StockLocation.where(propagate_all_variants: true).each do |stock_location|
+        stock_location.propagate_variant(self)
+      end
+    end
+
+    def in_stock_cache_key
+      "variant-#{id}-in_stock"
+    end
+
+    def clear_in_stock_cache
+      Rails.cache.delete(in_stock_cache_key)
+    end
+
+    def disable_sku_validation?
+      Harpiya::Config[:disable_sku_validation]
+    end
+  end
+end