harpiya_core 4.3.0.alpha

data/app/models/concerns/harpiya/calculated_adjustments.rb

@@ -0,0 +1,35 @@
+module Harpiya
+  module CalculatedAdjustments
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :calculator, class_name: 'Harpiya::Calculator', as: :calculable, inverse_of: :calculable, dependent: :destroy, autosave: true
+      accepts_nested_attributes_for :calculator
+      validates :calculator, presence: true
+      delegate :compute, to: :calculator
+
+      def self.calculators
+        harpiya_calculators.send model_name_without_harpiya_namespace
+      end
+
+      def calculator_type
+        calculator.class.to_s if calculator
+      end
+
+      def calculator_type=(calculator_type)
+        klass = calculator_type.constantize if calculator_type
+        self.calculator = klass.new if klass && !calculator.is_a?(klass)
+      end
+
+      private
+
+      def self.model_name_without_harpiya_namespace
+        to_s.tableize.tr('/', '_').sub('harpiya_', '')
+      end
+
+      def self.harpiya_calculators
+        Rails.application.config.harpiya.calculators
+      end
+    end
+  end
+end

data/app/models/concerns/harpiya/default_price.rb

@@ -0,0 +1,36 @@
+module Harpiya
+  module DefaultPrice
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :default_price,
+              -> { with_deleted.where(currency: Harpiya::Config[:currency]) },
+              class_name: 'Harpiya::Price',
+              dependent: :destroy
+
+      delegate :display_price, :display_amount, :price, :currency, :price=,
+               :price_including_vat_for, :currency=, :display_compare_at_price,
+               :compare_at_price, :compare_at_price=, to: :find_or_build_default_price
+
+      after_save :save_default_price
+
+      def has_default_price?
+        !default_price.nil?
+      end
+
+      def find_or_build_default_price
+        default_price || build_default_price
+      end
+
+      private
+
+      def default_price_changed?
+        default_price && (default_price.changed? || default_price.new_record?)
+      end
+
+      def save_default_price
+        default_price.save if default_price_changed?
+      end
+    end
+  end
+end

data/app/models/concerns/harpiya/display_link.rb

@@ -0,0 +1,34 @@
+module Harpiya
+  module DisplayLink
+    def link
+      case linked_resource_type
+      when 'Harpiya::Taxon'
+        return if linked_resource.nil?
+
+        if harpiya_routes.method_defined?(:nested_taxons_path)
+          harpiya_routes.nested_taxons_path(linked_resource.permalink)
+        else
+          "/#{Harpiya::Config[:storefront_taxons_path]}/#{linked_resource.permalink}"
+        end
+      when 'Harpiya::Product'
+        return if linked_resource.nil?
+
+        if harpiya_routes.method_defined?(:products_path)
+          harpiya_routes.product_path(linked_resource)
+        else
+          "/#{Harpiya::Config[:storefront_products_path]}/#{linked_resource.slug}"
+        end
+      when 'Home Page'
+        '/'
+      when 'URL'
+        destination
+      end
+    end
+
+    private
+
+    def harpiya_routes
+      Harpiya::Core::Engine.routes.url_helpers
+    end
+  end
+end

data/app/models/concerns/harpiya/display_money.rb

@@ -0,0 +1,32 @@
+module Harpiya
+  module DisplayMoney
+    ##
+    # Takes a list of methods that the base object wants to be able to use
+    # to display with Harpiya::Money, and turns them into display_* methods.
+    # Intended to help clean up some of the presentational logic that exists
+    # at the model layer.
+    #
+    #
+    # ==== Examples
+    # Decorate a method, with the default option of using the base object's
+    # currency
+    #
+    #     extend Harpiya::DisplayMoney
+    #     money_methods :tax_amount, :price
+    #
+    # Decorate a method, but with some additional options
+    #     extend Harpiya::DisplayMoney
+    #     money_methods tax_amount: { currency: "CAD", no_cents: true }, :price
+    def money_methods(*args)
+      args.each do |money_method|
+        money_method = { money_method => {} } unless money_method.is_a? Hash
+        money_method.each do |method_name, opts|
+          define_method("display_#{method_name}") do
+            default_opts = respond_to?(:currency) ? { currency: currency } : {}
+            Harpiya::Money.new(send(method_name), default_opts.merge(opts))
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/harpiya/filter_param.rb

@@ -0,0 +1,21 @@
+module Harpiya
+  module FilterParam
+    extend ActiveSupport::Concern
+
+    included do
+      before_save :set_filter_param
+    end
+
+    protected
+
+    def set_filter_param
+      return if param_candidate.blank?
+
+      self.filter_param = param_candidate.parameterize
+    end
+
+    def param_candidate
+      name
+    end
+  end
+end

data/app/models/concerns/harpiya/named_type.rb

@@ -0,0 +1,12 @@
+module Harpiya
+  module NamedType
+    extend ActiveSupport::Concern
+
+    included do
+      scope :active, -> { where(active: true) }
+      default_scope { order(Arel.sql("LOWER(#{table_name}.name)")) }
+
+      validates :name, presence: true, uniqueness: { case_sensitive: false }
+    end
+  end
+end

data/app/models/concerns/harpiya/number_as_param.rb

@@ -0,0 +1,9 @@
+module Harpiya
+  module NumberAsParam
+    extend ActiveSupport::Concern
+
+    def to_param
+      number.presence.to_s
+    end
+  end
+end

data/app/models/concerns/harpiya/product_scopes.rb

@@ -0,0 +1,310 @@
+module Harpiya
+  module ProductScopes
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :search_scopes do
+        []
+      end
+
+      def self.add_search_scope(name, &block)
+        singleton_class.send(:define_method, name.to_sym, &block)
+        search_scopes << name.to_sym
+      end
+
+      def self.simple_scopes
+        [
+          :ascend_by_updated_at,
+          :descend_by_updated_at,
+          :ascend_by_name,
+          :descend_by_name
+        ]
+      end
+
+      def self.add_simple_scopes(scopes)
+        scopes.each do |name|
+          # We should not define price scopes here, as they require something slightly different
+          next if name.to_s.include?('master_price')
+
+          parts = name.to_s.match(/(.*)_by_(.*)/)
+          scope(name.to_s, -> { order(Arel.sql("#{Product.quoted_table_name}.#{parts[2]} #{parts[1] == 'ascend' ? 'ASC' : 'DESC'}")) })
+        end
+      end
+
+      def self.property_conditions(property)
+        properties = Property.table_name
+        case property
+        when String   then { "#{properties}.name" => property }
+        when Property then { "#{properties}.id" => property.id }
+        else { "#{properties}.id" => property.to_i }
+        end
+      end
+
+      add_simple_scopes simple_scopes
+
+      add_search_scope :ascend_by_master_price do
+        order("#{price_table_name}.amount ASC")
+      end
+
+      add_search_scope :descend_by_master_price do
+        order("#{price_table_name}.amount DESC")
+      end
+
+      add_search_scope :price_between do |low, high|
+        where(Price.table_name => { amount: low..high })
+      end
+
+      add_search_scope :master_price_lte do |price|
+        where("#{price_table_name}.amount <= ?", price)
+      end
+
+      add_search_scope :master_price_gte do |price|
+        where("#{price_table_name}.amount >= ?", price)
+      end
+
+      add_search_scope :by_store do |store|
+        joins(:stores).where(Harpiya::StoreProduct.table_name => { store_id: store.id })
+      end
+
+      # This scope selects products in taxon AND all its descendants
+      # If you need products only within one taxon use
+      #
+      #   Harpiya::Product.joins(:taxons).where(Taxon.table_name => { id: taxon.id })
+      #
+      # If you're using count on the result of this scope, you must use the
+      # `:distinct` option as well:
+      #
+      #   Harpiya::Product.in_taxon(taxon).count(distinct: true)
+      #
+      # This is so that the count query is distinct'd:
+      #
+      #   SELECT COUNT(DISTINCT "harpiya_products"."id") ...
+      #
+      #   vs.
+      #
+      #   SELECT COUNT(*) ...
+      add_search_scope :in_taxon do |taxon|
+        includes(:classifications).
+          where('harpiya_products_taxons.taxon_id' => taxon.cached_self_and_descendants_ids).
+          order('harpiya_products_taxons.position ASC')
+      end
+
+      # This scope selects products in all taxons AND all its descendants
+      # If you need products only within one taxon use
+      #
+      #   Harpiya::Product.taxons_id_eq([x,y])
+      add_search_scope :in_taxons do |*taxons|
+        taxons = get_taxons(taxons)
+        taxons.first ? prepare_taxon_conditions(taxons) : where(nil)
+      end
+
+      add_search_scope :ascend_by_taxons_min_position do |taxon_ids|
+        joins(:classifications).
+          where(Classification.table_name => { taxon_id: taxon_ids }).
+          select(
+            [
+              "#{Product.table_name}.*",
+              "MIN(#{Classification.table_name}.position) AS min_position"
+            ].join(', ')
+          ).
+          group(:id).
+          order(min_position: :asc)
+      end
+
+      # a scope that finds all products having property specified by name, object or id
+      add_search_scope :with_property do |property|
+        joins(:properties).where(property_conditions(property))
+      end
+
+      # a simple test for product with a certain property-value pairing
+      # note that it can test for properties with NULL values, but not for absent values
+      add_search_scope :with_property_value do |property, value|
+        joins(:properties).
+          where("#{ProductProperty.table_name}.value = ?", value).
+          where(property_conditions(property))
+      end
+
+      add_search_scope :with_property_values do |property_filter_param, property_values|
+        joins(product_properties: :property).
+          where(Property.table_name => { filter_param: property_filter_param }).
+          where(ProductProperty.table_name => { filter_param: property_values.map(&:parameterize) })
+      end
+
+      add_search_scope :with_option do |option|
+        option_types = OptionType.table_name
+        conditions = case option
+                     when String     then { "#{option_types}.name" => option }
+                     when OptionType then { "#{option_types}.id" => option.id }
+                     else { "#{option_types}.id" => option.to_i }
+                     end
+
+        joins(:option_types).where(conditions)
+      end
+
+      add_search_scope :with_option_value do |option, value|
+        option_values = OptionValue.table_name
+        option_type_id = case option
+                         when String then OptionType.find_by(name: option) || option.to_i
+                         when OptionType then option.id
+                         else option.to_i
+                         end
+
+        conditions = "#{option_values}.name = ? AND #{option_values}.option_type_id = ?", value, option_type_id
+        group('harpiya_products.id').joins(variants_including_master: :option_values).where(conditions)
+      end
+
+      # Finds all products which have either:
+      # 1) have an option value with the name matching the one given
+      # 2) have a product property with a value matching the one given
+      add_search_scope :with do |value|
+        includes(variants_including_master: :option_values).
+          includes(:product_properties).
+          where("#{OptionValue.table_name}.name = ? OR #{ProductProperty.table_name}.value = ?", value, value)
+      end
+
+      # Finds all products that have a name containing the given words.
+      add_search_scope :in_name do |words|
+        like_any([:name], prepare_words(words))
+      end
+
+      # Finds all products that have a name or meta_keywords containing the given words.
+      add_search_scope :in_name_or_keywords do |words|
+        like_any([:name, :meta_keywords], prepare_words(words))
+      end
+
+      # Finds all products that have a name, description, meta_description or meta_keywords containing the given keywords.
+      add_search_scope :in_name_or_description do |words|
+        like_any([:name, :description, :meta_description, :meta_keywords], prepare_words(words))
+      end
+
+      # Finds all products that have the ids matching the given collection of ids.
+      # Alternatively, you could use find(collection_of_ids), but that would raise an exception if one product couldn't be found
+      add_search_scope :with_ids do |*ids|
+        where(id: ids)
+      end
+
+      # Sorts products from most popular (popularity is extracted from how many
+      # times use has put product in cart, not completed orders)
+      #
+      # there is alternative faster and more elegant solution, it has small drawback though,
+      # it doesn stack with other scopes :/
+      #
+      # joins: "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
+      # order: 'COALESCE(cnt, 0) DESC'
+      add_search_scope :descend_by_popularity do
+        joins(:master).
+          order(%Q{
+             COALESCE((
+               SELECT
+                 COUNT(#{LineItem.quoted_table_name}.id)
+               FROM
+                 #{LineItem.quoted_table_name}
+               JOIN
+                 #{Variant.quoted_table_name} AS popular_variants
+               ON
+                 popular_variants.id = #{LineItem.quoted_table_name}.variant_id
+               WHERE
+                 popular_variants.product_id = #{Product.quoted_table_name}.id
+             ), 0) DESC
+          })
+      end
+
+      add_search_scope :not_deleted do
+        where("#{Product.quoted_table_name}.deleted_at IS NULL or #{Product.quoted_table_name}.deleted_at >= ?", Time.zone.now)
+      end
+
+      def self.not_discontinued(only_not_discontinued = true)
+        if only_not_discontinued != '0' && only_not_discontinued
+          where("#{Product.quoted_table_name}.discontinue_on IS NULL or #{Product.quoted_table_name}.discontinue_on >= ?", Time.zone.now)
+        else
+          all
+        end
+      end
+      search_scopes << :not_discontinued
+
+      def self.with_currency(currency)
+        joins(variants_including_master: :prices).
+          where(Price.table_name => { currency: currency.upcase }).
+          where.not(Price.table_name => { amount: nil }).
+          distinct
+      end
+      search_scopes << :with_currency
+
+      # Can't use add_search_scope for this as it needs a default argument
+      def self.available(available_on = nil, currency = nil)
+        available_on ||= Time.current
+
+        scope = not_discontinued.where("#{Product.quoted_table_name}.available_on <= ?", available_on)
+
+        unless Harpiya::Config.show_products_without_price
+          currency ||= Harpiya::Config[:currency]
+          scope = scope.with_currency(currency)
+        end
+
+        scope
+      end
+      search_scopes << :available
+
+      def self.active(currency = nil)
+        available(nil, currency)
+      end
+      search_scopes << :active
+
+      def self.for_filters(currency, taxon: nil, store: nil)
+        scope = active(currency)
+        scope = scope.in_taxon(taxon) if taxon.present?
+        scope = scope.by_store(store) if store.present?
+        scope
+      end
+      search_scopes << :for_filters
+
+      def self.for_user(user = nil)
+        if user.try(:has_harpiya_role?, 'admin')
+          with_deleted
+        else
+          not_deleted.not_discontinued.where("#{Product.quoted_table_name}.available_on <= ?", Time.current)
+        end
+      end
+
+      add_search_scope :taxons_name_eq do |name|
+        group('harpiya_products.id').joins(:taxons).where(Taxon.arel_table[:name].eq(name))
+      end
+
+      def self.price_table_name
+        Price.quoted_table_name
+      end
+      private_class_method :price_table_name
+
+      # specifically avoid having an order for taxon search (conflicts with main order)
+      def self.prepare_taxon_conditions(taxons)
+        ids = taxons.map(&:cached_self_and_descendants_ids).flatten.uniq
+        joins(:classifications).where(Classification.table_name => { taxon_id: ids })
+      end
+      private_class_method :prepare_taxon_conditions
+
+      # Produce an array of keywords for use in scopes.
+      # Always return array with at least an empty string to avoid SQL errors
+      def self.prepare_words(words)
+        return [''] if words.blank?
+
+        a = words.split(/[,\s]/).map(&:strip)
+        a.any? ? a : ['']
+      end
+      private_class_method :prepare_words
+
+      def self.get_taxons(*ids_or_records_or_names)
+        taxons = Taxon.table_name
+        ids_or_records_or_names.flatten.map do |t|
+          case t
+          when Integer then Taxon.find_by(id: t)
+          when ApplicationRecord then t
+          when String
+            Taxon.find_by(name: t) ||
+              Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first
+          end
+        end.compact.flatten.uniq
+      end
+      private_class_method :get_taxons
+    end
+  end
+end