goca-spree-core 3.1.14.rails.5.0

data/app/models/spree/promotion.rb

@@ -0,0 +1,198 @@
+module Spree
+  class Promotion < Spree::Base
+    MATCH_POLICIES = %w(all any)
+    UNACTIVATABLE_ORDER_STATES = ["complete", "awaiting_return", "returned"]
+
+    attr_reader :eligibility_errors
+
+    belongs_to :promotion_category
+
+    has_many :promotion_rules, autosave: true, dependent: :destroy
+    alias_method :rules, :promotion_rules
+
+    has_many :promotion_actions, autosave: true, dependent: :destroy
+    alias_method :actions, :promotion_actions
+
+    has_many :order_promotions, class_name: 'Spree::OrderPromotion'
+    has_many :orders, through: :order_promotions, class_name: 'Spree::Order'
+
+    accepts_nested_attributes_for :promotion_actions, :promotion_rules
+
+    validates_associated :rules
+
+    validates :name, presence: true
+    validates :path, uniqueness: { allow_blank: true }
+    validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
+    validates :description, length: { maximum: 255 }, allow_blank: true
+
+    before_save :normalize_blank_values
+
+    scope :coupons, -> { where.not(code: nil) }
+    scope :advertised, -> { where(advertise: true) }
+    scope :applied, lambda {
+      joins(<<-SQL).uniq
+        INNER JOIN spree_order_promotions
+        ON spree_order_promotions.promotion_id = #{table_name}.id
+      SQL
+    }
+
+    self.whitelisted_ransackable_attributes = ['path', 'promotion_category_id', 'code']
+
+    def self.with_coupon_code(coupon_code)
+      where("lower(#{table_name}.code) = ?", coupon_code.strip.downcase)
+        .includes(:promotion_actions).where.not(spree_promotion_actions: { id: nil })
+        .first
+    end
+
+    def self.active
+      where('spree_promotions.starts_at IS NULL OR spree_promotions.starts_at < ?', Time.current).
+        where('spree_promotions.expires_at IS NULL OR spree_promotions.expires_at > ?', Time.current)
+    end
+
+    def self.order_activatable?(order)
+      order && !UNACTIVATABLE_ORDER_STATES.include?(order.state)
+    end
+
+    def expired?
+      !!(starts_at && Time.current < starts_at || expires_at && Time.current > expires_at)
+    end
+
+    def activate(payload)
+      order = payload[:order]
+      return unless self.class.order_activatable?(order)
+
+      payload[:promotion] = self
+
+      # Track results from actions to see if any action has been taken.
+      # Actions should return nil/false if no action has been taken.
+      # If an action returns true, then an action has been taken.
+      results = actions.map do |action|
+        action.perform(payload)
+      end
+      # If an action has been taken, report back to whatever activated this promotion.
+      action_taken = results.include?(true)
+
+      if action_taken
+      # connect to the order
+      # create the join_table entry.
+        self.orders << order
+        self.save
+      end
+
+      action_taken
+    end
+
+    # called anytime order.update_with_updater! happens
+    def eligible?(promotable)
+      return false if expired? || usage_limit_exceeded?(promotable) || blacklisted?(promotable)
+      !!eligible_rules(promotable, {})
+    end
+
+    # eligible_rules returns an array of promotion rules where eligible? is true for the promotable
+    # if there are no such rules, an empty array is returned
+    # if the rules make this promotable ineligible, then nil is returned (i.e. this promotable is not eligible)
+    def eligible_rules(promotable, options = {})
+      # Promotions without rules are eligible by default.
+      return [] if rules.none?
+      eligible = lambda { |r| r.eligible?(promotable, options) }
+      specific_rules = rules.select { |rule| rule.applicable?(promotable) }
+      return [] if specific_rules.none?
+
+      rule_eligibility = Hash[specific_rules.map do |rule|
+        [rule, rule.eligible?(promotable, options)]
+      end]
+
+      if match_all?
+        # If there are rules for this promotion, but no rules for this
+        # particular promotable, then the promotion is ineligible by default.
+        unless rule_eligibility.values.all?
+          @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
+          return nil
+        end
+        specific_rules
+      else
+        unless rule_eligibility.values.any?
+          @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
+          return nil
+        end
+
+        [rule_eligibility.detect { |_, eligibility| eligibility }.first]
+      end
+    end
+
+    def products
+      rules.where(type: "Spree::Promotion::Rules::Product").map(&:products).flatten.uniq
+    end
+
+    def usage_limit_exceeded?(promotable)
+      usage_limit.present? && usage_limit > 0 && adjusted_credits_count(promotable) >= usage_limit
+    end
+
+    def adjusted_credits_count(promotable)
+      adjustments = promotable.is_a?(Order) ? promotable.all_adjustments : promotable.adjustments
+      credits_count - adjustments.promotion.where(source_id: actions.pluck(:id)).size
+    end
+
+    def credits
+      Adjustment.eligible.promotion.where(source_id: actions.map(&:id))
+    end
+
+    def credits_count
+      credits.count
+    end
+
+    def line_item_actionable?(order, line_item)
+      if eligible? order
+        rules = eligible_rules(order)
+        if rules.blank?
+          true
+        else
+          rules.send(match_all? ? :all? : :any?) do |rule|
+            rule.actionable? line_item
+          end
+        end
+      else
+        false
+      end
+    end
+
+    def used_by?(user, excluded_orders = [])
+      [
+        :adjustments,
+        :line_item_adjustments,
+        :shipment_adjustments
+      ].any? do |adjustment_type|
+        user.orders.complete.joins(adjustment_type).where(
+          spree_adjustments: {
+            source_type: 'Spree::PromotionAction',
+            source_id: actions.map(&:id),
+            eligible: true
+          }
+        ).where.not(
+          id: excluded_orders.map(&:id)
+        ).any?
+      end
+    end
+
+    private
+    def blacklisted?(promotable)
+      case promotable
+      when Spree::LineItem
+        !promotable.product.promotionable?
+      when Spree::Order
+        promotable.line_items.any? &&
+          !promotable.line_items.joins(:product).where(spree_products: {promotionable: true}).any?
+      end
+    end
+
+    def normalize_blank_values
+      [:code, :path].each do |column|
+        self[column] = nil if self[column].blank?
+      end
+    end
+
+    def match_all?
+      match_policy == 'all'
+    end
+  end
+end

data/app/models/spree/promotion_action.rb

@@ -0,0 +1,25 @@
+## Base class for all types of promotion action.
+# PromotionActions perform the necessary tasks when a promotion is activated by an event and determined to be eligible.
+module Spree
+  class PromotionAction < Spree::Base
+    acts_as_paranoid
+
+    belongs_to :promotion, class_name: 'Spree::Promotion'
+
+    scope :of_type, ->(t) { where(type: t) }
+
+    # This method should be overriden in subclass
+    # Updates the state of the order or performs some other action depending on the subclass
+    # options will contain the payload from the event that activated the promotion. This will include
+    # the key :user which allows user based actions to be performed in addition to actions on the order
+    def perform(options = {})
+      raise 'perform should be implemented in a sub-class of PromotionAction'
+    end
+
+    protected
+
+    def label
+      Spree.t(:promotion_label, name: promotion.name)
+    end
+  end
+end

data/app/models/spree/promotion_action_line_item.rb

@@ -0,0 +1,6 @@
+module Spree
+  class PromotionActionLineItem < Spree::Base
+    belongs_to :promotion_action, class_name: 'Spree::Promotion::Actions::CreateLineItems'
+    belongs_to :variant, class_name: 'Spree::Variant'
+  end
+end

data/app/models/spree/promotion_category.rb

@@ -0,0 +1,6 @@
+module Spree
+  class PromotionCategory < Spree::Base
+    validates :name, presence: true
+    has_many :promotions
+  end
+end

data/app/models/spree/promotion_handler/cart.rb

@@ -0,0 +1,51 @@
+module Spree
+  module PromotionHandler
+    # Decides which promotion should be activated given the current order context
+    #
+    # By activated it doesn't necessarily mean that the order will have a
+    # discount for every activated promotion. It means that the discount will be
+    # created and might eventually become eligible. The intention here is to
+    # reduce overhead. e.g. a promotion that requires item A to be eligible
+    # shouldn't be eligible unless item A is added to the order.
+    #
+    # It can be used as a wrapper for custom handlers as well. Different
+    # applications might have completely different requirements to make
+    # the promotions system accurate and performant. Here they can plug custom
+    # handler to activate promos as they wish once an item is added to cart
+    class Cart
+      attr_reader :line_item, :order
+      attr_accessor :error, :success
+
+      def initialize(order, line_item=nil)
+        @order, @line_item = order, line_item
+      end
+
+      def activate
+        promotions.each do |promotion|
+          if (line_item && promotion.eligible?(line_item)) || promotion.eligible?(order)
+            promotion.activate(line_item: line_item, order: order)
+          end
+        end
+      end
+
+      private
+
+      def promotions
+        # AR cannot bind raw ASTs to prepared statements. There always must be a manager around.
+        # Also Postgresql requires an aliased table for `SELECT * FROM (subexpression) AS alias`.
+        # And Sqlite3 cannot work on outher parenthesis from `(left UNION right)`.
+        # So this construct makes both happy.
+        select = Arel::SelectManager.new(Promotion.arel_engine)
+        select.from(
+          Promotion.arel_table.create_table_alias(
+            order.promotions.active.union(Promotion.active.where(code: nil, path: nil)),
+            Promotion.table_name
+          )
+        )
+        select.project(Arel.star)
+
+        Promotion.find_by_sql(select.to_sql)
+      end
+    end
+  end
+end

data/app/models/spree/promotion_handler/coupon.rb

@@ -0,0 +1,107 @@
+module Spree
+  module PromotionHandler
+    class Coupon
+      attr_reader :order
+      attr_accessor :error, :success, :status_code
+
+      def initialize(order)
+        @order = order
+      end
+
+      def apply
+        if order.coupon_code.present?
+          if promotion.present? && promotion.actions.exists?
+            handle_present_promotion(promotion)
+          else
+            if Promotion.with_coupon_code(order.coupon_code).try(:expired?)
+              set_error_code :coupon_code_expired
+            else
+              set_error_code :coupon_code_not_found
+            end
+          end
+        end
+
+        self
+      end
+
+      def set_success_code(c)
+        @status_code = c
+        @success = Spree.t(c)
+      end
+
+      def set_error_code(c)
+        @status_code = c
+        @error = Spree.t(c)
+      end
+
+      def promotion
+        @promotion ||= Promotion.active.includes(:promotion_rules, :promotion_actions).with_coupon_code(order.coupon_code)
+      end
+
+      def successful?
+        success.present? && error.blank?
+      end
+
+      private
+
+      def handle_present_promotion(promotion)
+        return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded?(order)
+        return promotion_applied if promotion_exists_on_order?(order, promotion)
+        unless promotion.eligible?(order)
+          self.error = promotion.eligibility_errors.full_messages.first unless promotion.eligibility_errors.blank?
+          return (self.error || ineligible_for_this_order)
+        end
+
+        # If any of the actions for the promotion return `true`,
+        # then result here will also be `true`.
+        result = promotion.activate(:order => order)
+        if result
+          determine_promotion_application_result
+        else
+          set_error_code :coupon_code_unknown_error
+        end
+      end
+
+      def promotion_usage_limit_exceeded
+        set_error_code :coupon_code_max_usage
+      end
+
+      def ineligible_for_this_order
+        set_error_code :coupon_code_not_eligible
+      end
+
+      def promotion_applied
+        set_error_code :coupon_code_already_applied
+      end
+
+      def promotion_exists_on_order?(order, promotion)
+        order.promotions.include? promotion
+      end
+
+      def determine_promotion_application_result
+        # Check for applied adjustments.
+        discount = order.all_adjustments.promotion.eligible.detect do |p|
+          p.source.promotion.code.try(:downcase) == order.coupon_code.downcase
+        end
+
+        # Check for applied line items.
+        created_line_items = promotion.actions.detect { |a| a.type == 'Spree::Promotion::Actions::CreateLineItems' }
+
+        if discount || created_line_items
+          order.update_totals
+          order.persist_totals
+          set_success_code :coupon_code_applied
+        else
+          # if the promotion exists on an order, but wasn't found above,
+          # we've already selected a better promotion
+          if order.promotions.with_coupon_code(order.coupon_code)
+            set_error_code :coupon_code_better_exists
+          else
+            # if the promotion was created after the order
+            set_error_code :coupon_code_not_found
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree/promotion_handler/free_shipping.rb

@@ -0,0 +1,33 @@
+module Spree
+  module PromotionHandler
+    # Used for activating promotions with shipping rules
+    class FreeShipping
+      attr_reader :order, :order_promo_ids
+      attr_accessor :error, :success
+
+      def initialize(order)
+        @order = order
+        @order_promo_ids = order.promotions.pluck(:id)
+      end
+
+      def activate
+        promotions.each do |promotion|
+          next if promotion.code.present? && !order_promo_ids.include?(promotion.id)
+
+          if promotion.eligible?(order)
+            promotion.activate(order: order)
+          end
+        end
+      end
+
+      private
+
+      def promotions
+        Spree::Promotion.active.where(
+          id: Spree::Promotion::Actions::FreeShipping.pluck(:promotion_id),
+          path: nil
+        )
+      end
+    end
+  end
+end

data/app/models/spree/promotion_handler/page.rb

@@ -0,0 +1,24 @@
+module Spree
+  module PromotionHandler
+    class Page
+      attr_reader :order, :path
+
+      def initialize(order, path)
+        @order = order
+        @path = path.gsub(/\A\//, '')
+      end
+
+      def activate
+        if promotion && promotion.eligible?(order)
+          promotion.activate(:order => order)
+        end
+      end
+
+      private
+
+        def promotion
+          @promotion ||= Promotion.active.find_by(:path => path)
+        end
+    end
+  end
+end

data/app/models/spree/promotion_rule.rb

@@ -0,0 +1,43 @@
+# Base class for all promotion rules
+module Spree
+  class PromotionRule < Spree::Base
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules
+
+    scope :of_type, ->(t) { where(type: t) }
+
+    validate :unique_per_promotion, on: :create
+
+    def self.for(promotable)
+      all.select { |rule| rule.applicable?(promotable) }
+    end
+
+    def applicable?(promotable)
+      raise 'applicable? should be implemented in a sub-class of Spree::PromotionRule'
+    end
+
+    def eligible?(promotable, options = {})
+      raise 'eligible? should be implemented in a sub-class of Spree::PromotionRule'
+    end
+
+    # This states if a promotion can be applied to the specified line item
+    # It is true by default, but can be overridden by promotion rules to provide conditions
+    def actionable?(line_item)
+      true
+    end
+
+    def eligibility_errors
+      @eligibility_errors ||= ActiveModel::Errors.new(self)
+    end
+
+    private
+    def unique_per_promotion
+      if Spree::PromotionRule.exists?(promotion_id: promotion_id, type: self.class.name)
+        errors[:base] << "Promotion already contains this rule type"
+      end
+    end
+
+    def eligibility_error_message(key, options = {})
+      Spree.t(key, Hash[scope: [:eligibility_errors, :messages]].merge(options))
+    end
+  end
+end

data/app/models/spree/promotion_rule_taxon.rb

@@ -0,0 +1,9 @@
+module Spree
+  class PromotionRuleTaxon < Spree::Base
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
+    belongs_to :taxon, class_name: 'Spree::Taxon'
+
+    validates :promotion_rule, :taxon, presence: true
+    validates :promotion_rule_id, uniqueness: { scope: :taxon_id }, allow_nil: true
+  end
+end

data/app/models/spree/promotion_rule_user.rb

@@ -0,0 +1,9 @@
+module Spree
+  class PromotionRuleUser < Spree::Base
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
+    belongs_to :user, class_name: Spree.user_class
+
+    validates :user, :promotion_rule, presence: true
+    validates :user_id, uniqueness: { scope: :promotion_rule_id }, allow_nil: true
+  end
+end

data/app/models/spree/property.rb

@@ -0,0 +1,23 @@
+module Spree
+  class Property < Spree::Base
+    has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
+    has_many :prototypes, through: :property_prototypes, class_name: 'Spree::Prototype'
+
+    has_many :product_properties, dependent: :delete_all, inverse_of: :property
+    has_many :products, through: :product_properties
+
+    validates :name, :presentation, presence: true
+
+    scope :sorted, -> { order(:name) }
+
+    after_touch :touch_all_products
+
+    self.whitelisted_ransackable_attributes = ['presentation']
+
+    private
+
+    def touch_all_products
+      products.update_all(updated_at: Time.current)
+    end
+  end
+end

data/app/models/spree/property_prototype.rb

@@ -0,0 +1,9 @@
+module Spree
+  class PropertyPrototype < Spree::Base
+    belongs_to :prototype, class_name: 'Spree::Prototype'
+    belongs_to :property, class_name: 'Spree::Property'
+
+    validates :prototype, :property, presence: true
+    validates :prototype_id, uniqueness: { scope: :property_id }, allow_nil: true
+  end
+end

data/app/models/spree/prototype.rb

@@ -0,0 +1,14 @@
+module Spree
+  class Prototype < Spree::Base
+    has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
+    has_many :properties, through: :property_prototypes, class_name: 'Spree::Property'
+
+    has_many :option_type_prototypes, class_name: 'Spree::OptionTypePrototype'
+    has_many :option_types, through: :option_type_prototypes, class_name: 'Spree::OptionType'
+
+    has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon'
+    has_many :taxons, through: :prototype_taxons, class_name: 'Spree::Taxon'
+
+    validates :name, presence: true
+  end
+end

data/app/models/spree/prototype_taxon.rb

@@ -0,0 +1,9 @@
+module Spree
+  class PrototypeTaxon < Spree::Base
+    belongs_to :taxon, class_name: 'Spree::Taxon'
+    belongs_to :prototype, class_name: 'Spree::Prototype'
+
+    validates :prototype, :taxon, presence: true
+    validates :prototype_id, uniqueness: { scope: :taxon_id }, allow_nil: true
+  end
+end

data/app/models/spree/refund.rb

@@ -0,0 +1,89 @@
+module Spree
+  class Refund < Spree::Base
+    with_options inverse_of: :refunds do
+      belongs_to :payment
+      belongs_to :reimbursement
+    end
+    belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id
+
+    has_many :log_entries, as: :source
+
+    with_options presence: true do
+      validates :payment, :reason
+      # can't require this on create because the perform! in after_create needs to run first
+      validates :transaction_id, on: :update
+      validates :amount, numericality: { greater_than: 0, allow_nil: true }
+    end
+    validate :amount_is_less_than_or_equal_to_allowed_amount, on: :create
+
+    after_create :perform!
+    after_create :create_log_entry
+
+    scope :non_reimbursement, -> { where(reimbursement_id: nil) }
+
+    def money
+      Spree::Money.new(amount, { currency: payment.currency })
+    end
+    alias display_amount money
+
+    class << self
+      def total_amount_reimbursed_for(reimbursement)
+        reimbursement.refunds.to_a.sum(&:amount)
+      end
+    end
+
+    def description
+      payment.payment_method.name
+    end
+
+    private
+
+    # attempts to perform the refund.
+    # raises an error if the refund fails.
+    def perform!
+      return true if transaction_id.present?
+
+      credit_cents = Spree::Money.new(amount.to_f, currency: payment.currency).amount_in_cents
+
+      @response = process!(credit_cents)
+
+      self.transaction_id = @response.authorization
+      update_columns(transaction_id: transaction_id)
+      update_order
+    end
+
+    # return an activemerchant response object if successful or else raise an error
+    def process!(credit_cents)
+      response = if payment.payment_method.payment_profiles_supported?
+        payment.payment_method.credit(credit_cents, payment.source, payment.transaction_id, {originator: self})
+      else
+        payment.payment_method.credit(credit_cents, payment.transaction_id, {originator: self})
+      end
+
+      if !response.success?
+        logger.error(Spree.t(:gateway_error) + "  #{response.to_yaml}")
+        text = response.params['message'] || response.params['response_reason_text'] || response.message
+        raise Core::GatewayError.new(text)
+      end
+
+      response
+    rescue ActiveMerchant::ConnectionError => e
+      logger.error(Spree.t(:gateway_error) + "  #{e.inspect}")
+      raise Core::GatewayError.new(Spree.t(:unable_to_connect_to_gateway))
+    end
+
+    def create_log_entry
+      log_entries.create!(details: @response.to_yaml)
+    end
+
+    def amount_is_less_than_or_equal_to_allowed_amount
+      if amount > payment.credit_allowed
+        errors.add(:amount, :greater_than_allowed)
+      end
+    end
+
+    def update_order
+      payment.order.updater.update
+    end
+  end
+end

data/app/models/spree/refund_reason.rb

@@ -0,0 +1,13 @@
+module Spree
+  class RefundReason < Spree::Base
+    include Spree::NamedType
+
+    RETURN_PROCESSING_REASON = 'Return processing'
+
+    has_many :refunds, dependent: :restrict_with_error
+
+    def self.return_processing_reason
+      find_by!(name: RETURN_PROCESSING_REASON, mutable: false)
+    end
+  end
+end