solidus_core 1.0.0.pre

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

@@ -0,0 +1,43 @@
+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.codes.any? && !order_promo_ids.include?(promotion.id)
+
+          if promotion.eligible?(order)
+            promotion.activate(order: order)
+          end
+        end
+      end
+
+      private
+
+      def promotions
+        promo_table = Promotion.arel_table
+        code_table  = PromotionCode.arel_table
+
+        promotion_code_join = promo_table.join(code_table, Arel::Nodes::OuterJoin).on(
+          promo_table[:id].eq(code_table[:promotion_id])
+        ).join_sources
+
+        Spree::Promotion.active.
+          joins(promotion_code_join).
+          where({
+            id: Spree::Promotion::Actions::FreeShipping.pluck(:promotion_id), # This would probably be more efficient by joining instead
+            spree_promotion_codes: { id: nil },
+            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,44 @@
+module Spree
+  # Base class for all promotion rules
+  class PromotionRule < Spree::Base
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules
+
+    scope :of_type, ->(t) { where(type: t) }
+
+    validates :promotion, presence: true
+    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/property.rb

@@ -0,0 +1,20 @@
+module Spree
+  class Property < Spree::Base
+    has_and_belongs_to_many :prototypes, join_table: 'spree_properties_prototypes'
+
+    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
+
+    private
+
+    def touch_all_products
+      products.update_all(updated_at: Time.current)
+    end
+  end
+end

data/app/models/spree/prototype.rb

@@ -0,0 +1,9 @@
+module Spree
+  class Prototype < Spree::Base
+    has_and_belongs_to_many :properties, join_table: :spree_properties_prototypes
+    has_and_belongs_to_many :option_types, join_table: :spree_option_types_prototypes
+    has_and_belongs_to_many :taxons, join_table: :spree_taxons_prototypes
+
+    validates :name, presence: true
+  end
+end

data/app/models/spree/refund.rb

@@ -0,0 +1,96 @@
+module Spree
+  class Refund < Spree::Base
+    belongs_to :payment, inverse_of: :refunds
+    belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id
+    belongs_to :reimbursement, inverse_of: :refunds
+
+    has_many :log_entries, as: :source
+
+    validates :payment, presence: true
+    validates :reason, presence: true
+    validates :transaction_id, presence: true, on: :update # can't require this on create because the before_create needs to run first
+    validates :amount, presence: true, numericality: {greater_than: 0}
+
+    validate :check_payment_environment, on: :create, if: :payment
+    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).money.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
+
+    # Saftey check to make sure we're not accidentally performing operations on a live gateway.
+    # Ex. When testing in staging environment with a copy of production data.
+    def check_payment_environment
+      if payment.payment_method.environment != Rails.env
+        message = Spree.t(:gateway_config_unavailable) + " - #{Rails.env}"
+        errors.add(:base, message)
+      end
+    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
+
+    def self.return_processing_reason
+      find_by!(name: RETURN_PROCESSING_REASON, mutable: false)
+    end
+  end
+end

data/app/models/spree/reimbursement.rb

@@ -0,0 +1,188 @@
+module Spree
+  class Reimbursement < Spree::Base
+    class IncompleteReimbursementError < StandardError; end
+
+    belongs_to :order, inverse_of: :reimbursements
+    belongs_to :customer_return, inverse_of: :reimbursements, touch: true
+
+    has_many :refunds, inverse_of: :reimbursement
+    has_many :credits, inverse_of: :reimbursement, class_name: 'Spree::Reimbursement::Credit'
+
+    has_many :return_items, inverse_of: :reimbursement
+
+    validates :order, presence: true
+    validate :validate_return_items_belong_to_same_order
+
+    accepts_nested_attributes_for :return_items, allow_destroy: true
+
+    before_create :generate_number
+
+    scope :reimbursed, -> { where(reimbursement_status: 'reimbursed') }
+
+    # The reimbursement_tax_calculator property should be set to an object that responds to "call"
+    # and accepts a reimbursement object. Invoking "call" should update the tax fields on the
+    # associated ReturnItems.
+    # This allows a store to easily integrate with third party tax services.
+    class_attribute :reimbursement_tax_calculator
+    self.reimbursement_tax_calculator = ReimbursementTaxCalculator
+    # A separate attribute here allows you to use a more performant calculator for estimates
+    # and a different one (e.g. one that hits a 3rd party API) for the final caluclations.
+    class_attribute :reimbursement_simulator_tax_calculator
+    self.reimbursement_simulator_tax_calculator = ReimbursementTaxCalculator
+
+    # The reimbursement_models property should contain an array of all models that provide
+    # reimbursements.
+    # This allows a store to incorporate custom reimbursement methods that Spree doesn't know about.
+    # Each model must implement a "total_amount_reimbursed_for" method.
+    # Example:
+    #   Refund.total_amount_reimbursed_for(reimbursement)
+    # See the `reimbursement_generator` property regarding the generation of custom reimbursements.
+    class_attribute :reimbursement_models
+    self.reimbursement_models = [Refund, Reimbursement::Credit]
+
+    # The reimbursement_performer property should be set to an object that responds to the following methods:
+    # - #perform
+    # - #simulate
+    # see ReimbursementPerformer for details.
+    # This allows a store to customize their reimbursement methods and logic.
+    class_attribute :reimbursement_performer
+    self.reimbursement_performer = ReimbursementPerformer
+
+    # These are called if the call to "reimburse!" succeeds.
+    class_attribute :reimbursement_success_hooks
+    self.reimbursement_success_hooks = []
+
+    # These are called if the call to "reimburse!" fails.
+    class_attribute :reimbursement_failure_hooks
+    self.reimbursement_failure_hooks = []
+
+    state_machine :reimbursement_status, initial: :pending do
+
+      event :errored do
+        transition to: :errored, from: [:pending, :errored]
+      end
+
+      event :reimbursed do
+        transition to: :reimbursed, from: [:pending, :errored]
+      end
+
+    end
+
+    class << self
+      def build_from_customer_return(customer_return)
+        order = customer_return.order
+        order.reimbursements.build({
+          customer_return: customer_return,
+          return_items: customer_return.return_items.accepted.not_reimbursed,
+        })
+      end
+    end
+
+    def display_total
+      Spree::Money.new(total, { currency: order.currency })
+    end
+
+    def calculated_total
+      # rounding down to handle edge cases for consecutive partial returns where rounding
+      # might cause us to try to reimburse more than was originally billed
+      return_items.to_a.sum(&:total).to_d.round(2, :down)
+    end
+
+    def paid_amount
+      reimbursement_models.sum do |model|
+        model.total_amount_reimbursed_for(self)
+      end
+    end
+
+    def unpaid_amount
+      total - paid_amount
+    end
+
+    def perform!
+      reimbursement_tax_calculator.call(self)
+      reload
+      update!(total: calculated_total)
+
+      reimbursement_performer.perform(self)
+
+      if unpaid_amount_within_tolerance?
+        reimbursed!
+        reimbursement_success_hooks.each { |h| h.call self }
+        send_reimbursement_email
+      else
+        errored!
+        reimbursement_failure_hooks.each { |h| h.call self }
+        raise IncompleteReimbursementError, Spree.t("validation.unpaid_amount_not_zero", amount: unpaid_amount)
+      end
+    end
+
+    def simulate
+      reimbursement_simulator_tax_calculator.call(self)
+      reload
+      update!(total: calculated_total)
+
+      reimbursement_performer.simulate(self)
+    end
+
+    def return_items_requiring_exchange
+      return_items.select(&:exchange_required?)
+    end
+
+    def any_exchanges?
+      return_items.any?(&:exchange_processed?)
+    end
+
+    def all_exchanges?
+      return_items.all?(&:exchange_processed?)
+    end
+
+    private
+
+    def generate_number
+      self.number ||= loop do
+        random = "RI#{Array.new(9){rand(9)}.join}"
+        break random unless self.class.exists?(number: random)
+      end
+    end
+
+    def validate_return_items_belong_to_same_order
+      if return_items.any? { |ri| ri.inventory_unit.order_id != order_id }
+        errors.add(:base, :return_items_order_id_does_not_match)
+      end
+    end
+
+    def send_reimbursement_email
+      Spree::ReimbursementMailer.reimbursement_email(self.id).deliver_now
+    end
+
+    # If there are multiple different reimbursement types for a single
+    # reimbursement we open ourselves to a one-cent rounding error for every
+    # type over the first one. This is due to how we round #unpaid_amount and
+    # how each reimbursement type will round as well. Since at this point the
+    # payments and credits have already been processed, we should allow the
+    # reimbursement to show as 'reimbursed' and not 'errored'.
+    def unpaid_amount_within_tolerance?
+      reimbursement_count = reimbursement_models.count do |model|
+        model.total_amount_reimbursed_for(self) > 0
+      end
+      leniency = if reimbursement_count > 0
+                   (reimbursement_count - 1) * 0.01.to_d
+                 else
+                   0
+                 end
+      unpaid_amount.abs.between?(0, leniency)
+    end
+
+
+    # If there are multiple different reimbursement types for a single reimbursement,
+    # We open ourselves to a one-cent rounding error for every type over the first one.
+    # This is due to how we round #unpaid_amount and how each reimbursement type will round as well.
+    # Since at this point, the payments and credits have already been processed, we should
+    # allow the reimbursement to show as 'reimbursed' and not 'errored'
+    def unpaid_amount_within_tolerance?
+      reimbursement_count = reimbursement_models.count { |model| model.total_amount_reimbursed_for(self) > 0 }
+      leniency = reimbursement_count > 0 ? (reimbursement_count - 1) * 0.01.to_d : 0
+      unpaid_amount.abs.between?(0, leniency)
+    end
+  end
+end