goca-spree-core 3.1.14.rails.5.0

data/app/models/spree/stock_item.rb

@@ -0,0 +1,90 @@
+module Spree
+  class StockItem < Spree::Base
+    acts_as_paranoid
+
+    with_options inverse_of: :stock_items do
+      belongs_to :stock_location, class_name: 'Spree::StockLocation'
+      belongs_to :variant, class_name: 'Spree::Variant', counter_cache: true
+    end
+    has_many :stock_movements, inverse_of: :stock_item
+
+    validates :stock_location, :variant, presence: true
+    validates :variant_id, uniqueness: { scope: [:stock_location_id, :deleted_at] }, allow_blank: true
+
+    validates :count_on_hand, numericality: {
+                              greater_than_or_equal_to: 0,
+                              less_than_or_equal_to: 2**31 - 1,
+                              only_integer: true }, if: :verify_count_on_hand?
+
+    delegate :weight, :should_track_inventory?, to: :variant
+    delegate :name, to: :variant, prefix: true
+
+    after_save :conditional_variant_touch, if: :changed?
+    after_touch { variant.touch }
+    after_destroy { variant.touch }
+
+    self.whitelisted_ransackable_attributes = ['count_on_hand', 'stock_location_id']
+    self.whitelisted_ransackable_associations = ['variant']
+
+    scope :with_active_stock_location, -> { joins(:stock_location).merge(Spree::StockLocation.active) }
+
+    def backordered_inventory_units
+      Spree::InventoryUnit.backordered_for_stock_item(self)
+    end
+
+    def adjust_count_on_hand(value)
+      self.with_lock do
+        set_count_on_hand(count_on_hand + value)
+      end
+    end
+
+    def set_count_on_hand(value)
+      self.count_on_hand = value
+      process_backorders(count_on_hand - count_on_hand_was)
+
+      self.save!
+    end
+
+    def in_stock?
+      self.count_on_hand > 0
+    end
+
+    # Tells whether it's available to be included in a shipment
+    def available?
+      self.in_stock? || self.backorderable?
+    end
+
+    def variant
+      Spree::Variant.unscoped { super }
+    end
+
+    def reduce_count_on_hand_to_zero
+      self.set_count_on_hand(0) if count_on_hand > 0
+    end
+
+    private
+      def verify_count_on_hand?
+        count_on_hand_changed? && !backorderable? && (count_on_hand < count_on_hand_was) && (count_on_hand < 0)
+      end
+
+      # Process backorders based on amount of stock received
+      # If stock was -20 and is now -15 (increase of 5 units), then we should process 5 inventory orders.
+      # If stock was -20 but then was -25 (decrease of 5 units), do nothing.
+      def process_backorders(number)
+        if number > 0
+          backordered_inventory_units.first(number).each do |unit|
+            unit.fill_backorder
+          end
+        end
+      end
+
+      def conditional_variant_touch
+        # the variant_id changes from nil when a new stock location is added
+        stock_changed = (count_on_hand_changed? && count_on_hand_change.any?(&:zero?)) || variant_id_changed?
+
+        if !Spree::Config.binary_inventory_cache || stock_changed
+          variant.touch
+        end
+      end
+  end
+end

data/app/models/spree/stock_location.rb

@@ -0,0 +1,115 @@
+module Spree
+  class StockLocation < Spree::Base
+    has_many :shipments
+    has_many :stock_items, dependent: :delete_all, inverse_of: :stock_location
+    has_many :stock_movements, through: :stock_items
+
+    belongs_to :state, class_name: 'Spree::State'
+    belongs_to :country, class_name: 'Spree::Country'
+
+    validates :name, presence: true
+
+    scope :active, -> { where(active: true) }
+    scope :order_default, -> { order(default: :desc, name: :asc) }
+
+    after_create :create_stock_items, if: :propagate_all_variants?
+    after_save :ensure_one_default
+
+    def state_text
+      state.try(:abbr) || state.try(:name) || state_name
+    end
+
+    # Wrapper for creating a new stock item respecting the backorderable config
+    def propagate_variant(variant)
+      self.stock_items.create!(variant: variant, backorderable: self.backorderable_default)
+    end
+
+    # Return either an existing stock item or create a new one. Useful in
+    # scenarios where the user might not know whether there is already a stock
+    # item for a given variant
+    def set_up_stock_item(variant)
+      self.stock_item(variant) || propagate_variant(variant)
+    end
+
+    # Returns an instance of StockItem for the variant id.
+    #
+    # @param variant_id [String] The id of a variant.
+    #
+    # @return [StockItem] Corresponding StockItem for the StockLocation's variant.
+    def stock_item(variant_id)
+      stock_items.where(variant_id: variant_id).order(:id).first
+    end
+
+    # Attempts to look up StockItem for the variant, and creates one if not found.
+    # This method accepts an instance of the variant.
+    # Other methods in this model attempt to pass a variant,
+    # but controller actions can pass just the variant id as a parameter.
+    #
+    # @param variant [Variant] Variant instance.
+    #
+    # @return [StockItem] Corresponding StockItem for the StockLocation's variant.
+    def stock_item_or_create(variant)
+      stock_item(variant) || stock_items.create(variant_id: variant.id)
+    end
+
+    def count_on_hand(variant)
+      stock_item(variant).try(:count_on_hand)
+    end
+
+    def backorderable?(variant)
+      stock_item(variant).try(:backorderable?)
+    end
+
+    def restock(variant, quantity, originator = nil)
+      move(variant, quantity, originator)
+    end
+
+    def restock_backordered(variant, quantity, originator = nil)
+      item = stock_item_or_create(variant)
+      item.update_columns(
+        count_on_hand: item.count_on_hand + quantity,
+        updated_at: Time.current
+      )
+    end
+
+    def unstock(variant, quantity, originator = nil)
+      move(variant, -quantity, originator)
+    end
+
+    def move(variant, quantity, originator = nil)
+      stock_item_or_create(variant).stock_movements.create!(quantity: quantity,
+                                                            originator: originator)
+    end
+
+    def fill_status(variant, quantity)
+      if item = stock_item(variant)
+
+        if item.count_on_hand >= quantity
+          on_hand = quantity
+          backordered = 0
+        else
+          on_hand = item.count_on_hand
+          on_hand = 0 if on_hand < 0
+          backordered = item.backorderable? ? (quantity - on_hand) : 0
+        end
+
+        [on_hand, backordered]
+      else
+        [0, 0]
+      end
+    end
+
+    private
+      def create_stock_items
+        Variant.includes(:product).find_each do |variant|
+          propagate_variant(variant)
+        end
+      end
+
+      def ensure_one_default
+        if self.default
+          StockLocation.where(default: true).where.not(id: self.id).update_all(default: false)
+        end
+      end
+  end
+end

data/app/models/spree/stock_movement.rb

@@ -0,0 +1,35 @@
+module Spree
+  class StockMovement < Spree::Base
+    belongs_to :stock_item, class_name: 'Spree::StockItem', inverse_of: :stock_movements
+    belongs_to :originator, polymorphic: true
+
+    after_create :update_stock_item_quantity
+
+    with_options presence: true do
+      validates :stock_item
+      validates :quantity, numericality: {
+                                            greater_than_or_equal_to: -2**31,
+                                            less_than_or_equal_to: 2**31 - 1,
+                                            only_integer: true,
+                                            allow_nil: true
+                                          }
+    end
+
+    scope :recent, -> { order(created_at: :desc) }
+
+    self.whitelisted_ransackable_attributes = ['quantity']
+
+    def readonly?
+      !new_record?
+    end
+
+    private
+
+    def update_stock_item_quantity
+      return unless self.stock_item.should_track_inventory?
+      stock_item.adjust_count_on_hand quantity
+    end
+
+  end
+end
+

data/app/models/spree/stock_transfer.rb

@@ -0,0 +1,50 @@
+module Spree
+  class StockTransfer < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'T')
+
+    extend FriendlyId
+    friendly_id :number, slug_column: :number, use: :slugged
+
+    has_many :stock_movements, as: :originator
+
+    belongs_to :source_location, class_name: 'StockLocation'
+    belongs_to :destination_location, class_name: 'StockLocation'
+
+    self.whitelisted_ransackable_attributes = %w[reference source_location_id destination_location_id number]
+
+    def to_param
+      number
+    end
+
+    def source_movements
+      find_stock_location_with_location_id(source_location_id)
+    end
+
+    def destination_movements
+      find_stock_location_with_location_id(destination_location_id)
+    end
+
+    def transfer(source_location, destination_location, variants)
+      transaction do
+        variants.each_pair do |variant, quantity|
+          source_location.unstock(variant, quantity, self) if source_location
+          destination_location.restock(variant, quantity, self)
+
+          self.source_location = source_location
+          self.destination_location = destination_location
+          self.save!
+        end
+      end
+    end
+
+    def receive(destination_location, variants)
+      transfer(nil, destination_location, variants)
+    end
+
+    private
+
+    def find_stock_location_with_location_id(location_id)
+      stock_movements.joins(:stock_item).where('spree_stock_items.stock_location_id' => location_id)
+    end
+  end
+end

data/app/models/spree/store.rb

@@ -0,0 +1,48 @@
+module Spree
+  class Store < Spree::Base
+    has_many :orders, class_name: "Spree::Order"
+
+    with_options presence: true do
+      validates :code, uniqueness: { allow_blank: true }
+      validates :name, :url, :mail_from_address
+    end
+
+    before_save :ensure_default_exists_and_is_unique
+    before_destroy :validate_not_default
+
+    scope :by_url, lambda { |url| where("url like ?", "%#{url}%") }
+
+    after_commit :clear_cache
+
+    def self.current(domain = nil)
+      current_store = domain ? Store.by_url(domain).first : nil
+      current_store || Store.default
+    end
+
+    def self.default
+      Rails.cache.fetch("default_store") do
+        where(default: true).first_or_initialize
+      end
+    end
+
+    private
+
+    def ensure_default_exists_and_is_unique
+      if default
+        Store.where.not(id: id).update_all(default: false)
+      elsif Store.where(default: true).count.zero?
+        self.default = true
+      end
+    end
+
+    def validate_not_default
+      if default
+        errors.add(:base, :cannot_destroy_default_store)
+      end
+    end
+
+    def clear_cache
+      Rails.cache.delete("default_store")
+    end
+  end
+end

data/app/models/spree/store_credit.rb

@@ -0,0 +1,252 @@
+module Spree
+  class StoreCredit < Spree::Base
+    acts_as_paranoid
+
+    VOID_ACTION       = 'void'.freeze
+    CANCEL_ACTION     = 'cancel'.freeze
+    CREDIT_ACTION     = 'credit'.freeze
+    CAPTURE_ACTION    = 'capture'.freeze
+    ELIGIBLE_ACTION   = 'eligible'.freeze
+    AUTHORIZE_ACTION  = 'authorize'.freeze
+    ALLOCATION_ACTION = 'allocation'.freeze
+
+    DEFAULT_CREATED_BY_EMAIL = 'spree@example.com'.freeze
+
+    belongs_to :user, class_name: Spree.user_class.to_s, foreign_key: 'user_id'
+    belongs_to :category, class_name: "Spree::StoreCreditCategory"
+    belongs_to :created_by, class_name: Spree.user_class.to_s, foreign_key: 'created_by_id'
+    belongs_to :credit_type, class_name: 'Spree::StoreCreditType', foreign_key: 'type_id'
+    has_many :store_credit_events
+
+    validates_presence_of :user, :category, :credit_type, :created_by, :currency
+    validates_numericality_of :amount, greater_than: 0
+    validates_numericality_of :amount_used, greater_than_or_equal_to: 0
+    validate :amount_used_less_than_or_equal_to_amount
+    validate :amount_authorized_less_than_or_equal_to_amount
+
+    delegate :name, to: :category, prefix: true
+    delegate :email, to: :created_by, prefix: true
+
+    scope :order_by_priority, -> { includes(:credit_type).order('spree_store_credit_types.priority ASC') }
+
+    before_validation :associate_credit_type
+    after_save :store_event
+    before_destroy :validate_no_amount_used
+
+    attr_accessor :action, :action_amount, :action_originator, :action_authorization_code
+
+    def display_amount
+      Spree::Money.new(amount)
+    end
+
+    def display_amount_used
+      Spree::Money.new(amount_used)
+    end
+
+    def amount_remaining
+      amount - amount_used - amount_authorized
+    end
+
+    def authorize(amount, order_currency, options = {})
+      authorization_code = options[:action_authorization_code]
+      if authorization_code
+        if store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
+          # Don't authorize again on capture
+          return true
+        end
+      else
+        authorization_code = generate_authorization_code
+      end
+
+      if validate_authorization(amount, order_currency)
+        update_attributes!(
+          action: AUTHORIZE_ACTION,
+          action_amount: amount,
+          action_originator: options[:action_originator],
+          action_authorization_code: authorization_code,
+          amount_authorized: amount_authorized + amount
+        )
+        authorization_code
+      else
+        errors.add(:base, Spree.t('store_credit_payment_method.insufficient_authorized_amount'))
+        false
+      end
+    end
+
+    def validate_authorization(amount, order_currency)
+      if amount_remaining.to_d < amount.to_d
+        errors.add(:base, Spree.t('store_credit_payment_method.insufficient_funds'))
+      elsif currency != order_currency
+        errors.add(:base, Spree.t('store_credit_payment_method.currency_mismatch'))
+      end
+      errors.blank?
+    end
+
+    def capture(amount, authorization_code, order_currency, options = {})
+      return false unless authorize(amount, order_currency, action_authorization_code: authorization_code)
+
+      if amount <= amount_authorized
+        if currency != order_currency
+          errors.add(:base, Spree.t('store_credit_payment_method.currency_mismatch'))
+          false
+        else
+          update_attributes!(
+            action: CAPTURE_ACTION,
+            action_amount: amount,
+            action_originator: options[:action_originator],
+            action_authorization_code: authorization_code,
+            amount_used: amount_used + amount,
+            amount_authorized: amount_authorized - amount
+          )
+          authorization_code
+        end
+      else
+        errors.add(:base, Spree.t('store_credit_payment_method.insufficient_authorized_amount'))
+        false
+      end
+    end
+
+    def void(authorization_code, options = {})
+      if auth_event = store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
+        update_attributes!(
+          action: VOID_ACTION,
+          action_amount: auth_event.amount,
+          action_authorization_code: authorization_code,
+          action_originator: options[:action_originator],
+          amount_authorized: amount_authorized - auth_event.amount
+        )
+        true
+      else
+        errors.add(:base, Spree.t('store_credit_payment_method.unable_to_void', auth_code: authorization_code))
+        false
+      end
+    end
+
+    def credit(amount, authorization_code, order_currency, options = {})
+      # Find the amount related to this authorization_code in order to add the store credit back
+      capture_event = store_credit_events.find_by(action: CAPTURE_ACTION, authorization_code: authorization_code)
+
+      if currency != order_currency # sanity check to make sure the order currency hasn't changed since the auth
+        errors.add(:base, Spree.t('store_credit_payment_method.currency_mismatch'))
+        false
+      elsif capture_event && amount <= capture_event.amount
+        action_attributes = {
+          action: CREDIT_ACTION,
+          action_amount: amount,
+          action_originator: options[:action_originator],
+          action_authorization_code: authorization_code
+        }
+        create_credit_record(amount, action_attributes)
+        true
+      else
+        errors.add(:base, Spree.t('store_credit_payment_method.unable_to_credit', auth_code: authorization_code))
+        false
+      end
+    end
+
+    def actions
+      [CAPTURE_ACTION, VOID_ACTION, CREDIT_ACTION]
+    end
+
+    def can_capture?(payment)
+      payment.pending? || payment.checkout?
+    end
+
+    def can_void?(payment)
+      payment.pending?
+    end
+
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed > 0
+    end
+
+    def generate_authorization_code
+      "#{id}-SC-#{Time.now.utc.strftime('%Y%m%d%H%M%S%6N')}"
+    end
+
+    class << self
+      def default_created_by
+        Spree.user_class.find_by(email: DEFAULT_CREATED_BY_EMAIL)
+      end
+    end
+
+    private
+
+    def create_credit_record(amount, action_attributes = {})
+      # Setting credit_to_new_allocation to true will create a new allocation anytime #credit is called
+      # If it is not set, it will update the store credit's amount in place
+      credit = if Spree::Config.credit_to_new_allocation
+                 Spree::StoreCredit.new(create_credit_record_params(amount))
+               else
+                 self.amount_used = amount_used - amount
+                 self
+               end
+
+      credit.assign_attributes(action_attributes)
+      credit.save!
+    end
+
+    def create_credit_record_params(amount)
+      {
+        amount: amount,
+        user_id: user_id,
+        category_id: category_id,
+        created_by_id: created_by_id,
+        currency: currency,
+        type_id: type_id,
+        memo: credit_allocation_memo
+      }
+    end
+
+    def credit_allocation_memo
+      "This is a credit from store credit ID #{id}"
+    end
+
+    def store_event
+      return unless amount_changed? || amount_used_changed? || amount_authorized_changed? || action == ELIGIBLE_ACTION
+
+      event = if action
+                store_credit_events.build(action: action)
+              else
+                store_credit_events.where(action: ALLOCATION_ACTION).first_or_initialize
+              end
+
+      event.update_attributes!(
+        amount: action_amount || amount,
+        authorization_code: action_authorization_code || event.authorization_code || generate_authorization_code,
+        user_total_amount: user.total_available_store_credit,
+        originator: action_originator
+      )
+    end
+
+    def amount_used_less_than_or_equal_to_amount
+      return true if amount_used.nil?
+
+      if amount_used > amount
+        errors.add(:amount_used, :cannot_be_greater_than_amount)
+        false
+      end
+    end
+
+    def amount_authorized_less_than_or_equal_to_amount
+      if (amount_used + amount_authorized) > amount
+        errors.add(:amount_authorized, :exceeds_total_credits)
+        false
+      end
+    end
+
+    def validate_no_amount_used
+      if amount_used > 0
+        errors.add(:amount_used, :greater_than_zero_restrict_delete)
+        false
+      end
+    end
+
+    def associate_credit_type
+      unless type_id
+        credit_type_name = category.try(:non_expiring?) ? 'Non-expiring' : 'Expiring'
+        self.credit_type = Spree::StoreCreditType.find_by_name(credit_type_name)
+      end
+    end
+  end
+end

data/app/models/spree/store_credit_category.rb

@@ -0,0 +1,22 @@
+module Spree
+  class StoreCreditCategory < Spree::Base
+    validates_presence_of :name
+
+    GIFT_CARD_CATEGORY_NAME = 'Gift Card'.freeze
+    DEFAULT_NON_EXPIRING_TYPES = [GIFT_CARD_CATEGORY_NAME]
+
+    def non_expiring?
+      non_expiring_category_types.include? name
+    end
+
+    def non_expiring_category_types
+      DEFAULT_NON_EXPIRING_TYPES | Spree::Config[:non_expiring_credit_types]
+    end
+
+    class << self
+      def default_reimbursement_category(_options = {})
+        Spree::StoreCreditCategory.first
+      end
+    end
+  end
+end

data/app/models/spree/store_credit_event.rb

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

data/app/models/spree/store_credit_type.rb

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

data/app/models/spree/tax_category.rb

@@ -0,0 +1,18 @@
+module Spree
+  class TaxCategory < Spree::Base
+    acts_as_paranoid
+    validates :name, presence: true, uniqueness: { case_sensitive: false, scope: :deleted_at, allow_blank: true }
+
+    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