solidus_core 1.0.0.pre

data/app/models/spree/customer_return.rb

@@ -0,0 +1,73 @@
+module Spree
+  class CustomerReturn < Spree::Base
+    belongs_to :stock_location
+
+    has_many :return_items, inverse_of: :customer_return
+    has_many :return_authorizations, through: :return_items
+    has_many :reimbursements, inverse_of: :customer_return
+
+    after_create :process_return!
+    before_create :generate_number
+
+    validates :return_items, presence: true
+    validates :stock_location, presence: true
+    validate :return_items_belong_to_same_order
+
+    accepts_nested_attributes_for :return_items
+
+    extend DisplayMoney
+    money_methods pre_tax_total: { currency: Spree::Config[:currency] },
+                  total: { currency: Spree::Config[:currency] }
+
+    def total
+      return_items.map(&:total).sum
+    end
+
+    def pre_tax_total
+      return_items.sum(:pre_tax_amount)
+    end
+
+    # Temporarily tie a customer_return to one order
+    def order
+      return nil if return_items.blank?
+      return_items.first.inventory_unit.order
+    end
+
+    def order_id
+      order.try(:id)
+    end
+
+    def fully_reimbursed?
+      completely_decided? && return_items.accepted.includes(:reimbursement).all? { |return_item| return_item.reimbursement.try(:reimbursed?) }
+    end
+
+    def completely_decided?
+      !return_items.undecided.exists?
+    end
+
+    def process_return!
+      order.return! if order.all_inventory_units_returned?
+    end
+
+    private
+
+    def generate_number
+      self.number ||= loop do
+        random = "CR#{Array.new(9){rand(9)}.join}"
+        break random unless self.class.exists?(number: random)
+      end
+    end
+
+    def return_items_belong_to_same_order
+      if return_items.select{ |return_item| return_item.inventory_unit.order_id != order_id }.any?
+        errors.add(:base, Spree.t(:return_items_cannot_be_associated_with_multiple_orders))
+      end
+    end
+
+    def inventory_units
+      return_items.flat_map(&:inventory_unit)
+    end
+
+  end
+end
+

data/app/models/spree/exchange.rb

@@ -0,0 +1,46 @@
+module Spree
+  class Exchange
+    class UnableToCreateShipments < StandardError; end
+
+    def initialize(order, reimbursement_objects)
+      @order = order
+      @reimbursement_objects = reimbursement_objects
+    end
+
+    def description
+      @reimbursement_objects.map do |reimbursement_object|
+        "#{reimbursement_object.variant.options_text} => #{reimbursement_object.exchange_variant.options_text}"
+      end.join(" | ")
+    end
+
+    def display_amount
+      Spree::Money.new @reimbursement_objects.map(&:total).sum
+    end
+
+    def perform!
+      shipments = Spree::Stock::Coordinator.new(@order, @reimbursement_objects.map(&:build_exchange_inventory_unit)).shipments
+      if shipments.flat_map(&:inventory_units).size != @reimbursement_objects.size
+        raise UnableToCreateShipments.new("Could not generate shipments for all items. Out of stock?")
+      end
+      @order.shipments += shipments
+      @order.save!
+      shipments.each do |shipment|
+        shipment.update!(@order)
+        shipment.finalize!
+      end
+    end
+
+    def to_key
+      nil
+    end
+
+    def self.param_key
+      "spree_exchange"
+    end
+
+    def self.model_name
+      Spree::Exchange
+    end
+
+  end
+end

data/app/models/spree/gateway.rb

@@ -0,0 +1,79 @@
+module Spree
+  class Gateway < PaymentMethod
+    delegate :authorize, :purchase, :capture, :void, :credit, to: :provider
+
+    validates :name, :type, presence: true
+
+    preference :server, :string, default: 'test'
+    preference :test_mode, :boolean, default: true
+
+    def payment_source_class
+      CreditCard
+    end
+
+    # instantiates the selected gateway and configures with the options stored in the database
+    def self.current
+      super
+    end
+
+    def provider
+      gateway_options = options
+      gateway_options.delete :login if gateway_options.has_key?(:login) and gateway_options[:login].nil?
+      if gateway_options[:server]
+        ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
+      end
+      @provider ||= provider_class.new(gateway_options)
+    end
+
+    def options
+      self.preferences.inject({}){ |memo, (key, value)| memo[key.to_sym] = value; memo }
+    end
+
+    def method_missing(method, *args)
+      if provider.nil? || !provider.respond_to?(method)
+        super
+      else
+        provider.send(method, *args)
+      end
+    end
+
+    def payment_profiles_supported?
+      false
+    end
+
+    def method_type
+      'gateway'
+    end
+
+    def supports?(source)
+      return true unless provider_class.respond_to? :supports?
+      return false unless source.brand
+      provider_class.supports?(source.brand)
+    end
+
+    def disable_customer_profile(source)
+      if source.is_a? CreditCard
+        source.update_column :gateway_customer_profile_id, nil
+      else
+        raise 'You must implement disable_customer_profile method for this gateway.'
+      end
+    end
+
+    def sources_by_order(order)
+      source_ids = order.payments.where(payment_method_id: self.id).pluck(:source_id).uniq
+      payment_source_class.where(id: source_ids).with_payment_profile
+    end
+
+    def reusable_sources(order)
+      if order.completed?
+        sources_by_order order
+      else
+        if order.user_id
+          self.credit_cards.where(user_id: order.user_id).with_payment_profile
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/app/models/spree/gateway/bogus.rb

@@ -0,0 +1,91 @@
+module Spree
+  class Gateway::Bogus < Gateway
+    TEST_VISA = ['4111111111111111','4012888888881881','4222222222222']
+    TEST_MC   = ['5500000000000004','5555555555554444','5105105105105100']
+    TEST_AMEX = ['378282246310005','371449635398431','378734493671000','340000000000009']
+    TEST_DISC = ['6011000000000004','6011111111111117','6011000990139424']
+
+    VALID_CCS = ['1', TEST_VISA, TEST_MC, TEST_AMEX, TEST_DISC].flatten
+
+    attr_accessor :test
+
+    def provider_class
+      self.class
+    end
+
+    def preferences
+      {}
+    end
+
+    def create_profile(payment)
+      return if payment.source.has_payment_profile?
+      # simulate the storage of credit card profile using remote service
+      if success = VALID_CCS.include?(payment.source.number)
+        payment.source.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
+      end
+    end
+
+    def authorize(money, credit_card, options = {})
+      profile_id = credit_card.gateway_customer_profile_id
+      if VALID_CCS.include? credit_card.number or (profile_id and profile_id.starts_with? 'BGS-')
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'D' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
+      end
+    end
+
+    def purchase(money, credit_card, options = {})
+      profile_id = credit_card.gateway_customer_profile_id
+      if VALID_CCS.include? credit_card.number  or (profile_id and profile_id.starts_with? 'BGS-')
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'M' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
+      end
+    end
+
+    def credit(money, credit_card, response_code, options = {})
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+    end
+
+    def capture(money, authorization, gateway_options)
+      if authorization == '12345'
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true)
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :error => 'Bogus Gateway: Forced failure', :test => true)
+      end
+
+    end
+
+    def void(response_code, credit_card, options = {})
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+    end
+
+    def cancel(response_code)
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+    end
+
+    def test?
+      # Test mode is not really relevant with bogus gateway (no such thing as live server)
+      true
+    end
+
+    def payment_profiles_supported?
+      true
+    end
+
+    def actions
+      %w(capture void credit)
+    end
+
+    private
+      def generate_profile_id(success)
+        record = true
+        prefix = success ? 'BGS' : 'FAIL'
+        while record
+          random = "#{prefix}-#{Array.new(6){rand(6)}.join}"
+          record = CreditCard.where(:gateway_customer_profile_id => random).first
+        end
+        random
+      end
+  end
+end

data/app/models/spree/gateway/bogus_simple.rb

@@ -0,0 +1,26 @@
+module Spree
+  # Bogus Gateway that doesn't support payment profiles.
+  class Gateway::BogusSimple < Gateway::Bogus
+
+    def payment_profiles_supported?
+      false
+    end
+
+    def authorize(money, credit_card, options = {})
+      if VALID_CCS.include? credit_card.number
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
+      end
+    end
+
+    def purchase(money, credit_card, options = {})
+      if VALID_CCS.include? credit_card.number
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
+      end
+    end
+
+  end
+end

data/app/models/spree/image.rb

@@ -0,0 +1,44 @@
+module Spree
+  class Image < Asset
+    validate :no_attachment_errors
+
+    has_attached_file :attachment,
+                      styles: { mini: '48x48>', small: '100x100>', product: '240x240>', large: '600x600>' },
+                      default_style: :product,
+                      default_url: 'noimage/:style.png',
+                      url: '/spree/products/:id/:style/:basename.:extension',
+                      path: ':rails_root/public/spree/products/:id/:style/:basename.:extension',
+                      convert_options: { all: '-strip -auto-orient -colorspace sRGB' }
+    validates_attachment :attachment,
+      :presence => true,
+      :content_type => { :content_type => %w(image/jpeg image/jpg image/png image/gif) }
+
+    # save the w,h of the original image (from which others can be calculated)
+    # we need to look at the write-queue for images which have not been saved yet
+    after_post_process :find_dimensions
+
+    #used by admin products autocomplete
+    def mini_url
+      attachment.url(:mini, false)
+    end
+
+    def find_dimensions
+      temporary = attachment.queued_for_write[:original]
+      filename = temporary.path unless temporary.nil?
+      filename = attachment.path if filename.blank?
+      geometry = Paperclip::Geometry.from_file(filename)
+      self.attachment_width  = geometry.width
+      self.attachment_height = geometry.height
+    end
+
+    # if there are errors from the plugin, then add a more meaningful message
+    def no_attachment_errors
+      unless attachment.errors.empty?
+        # uncomment this to get rid of the less-than-useful interim messages
+        # errors.clear
+        errors.add :attachment, "Paperclip returned errors for file '#{attachment_file_name}' - check ImageMagick installation or image source file."
+        false
+      end
+    end
+  end
+end

data/app/models/spree/inventory_unit.rb

@@ -0,0 +1,154 @@
+module Spree
+  class InventoryUnit < Spree::Base
+    PRE_SHIPMENT_STATES = %w(backordered on_hand)
+    POST_SHIPMENT_STATES = %w(returned)
+    CANCELABLE_STATES = ['on_hand', 'backordered']
+
+    belongs_to :variant, class_name: "Spree::Variant", inverse_of: :inventory_units
+    belongs_to :order, class_name: "Spree::Order", inverse_of: :inventory_units
+    belongs_to :shipment, class_name: "Spree::Shipment", touch: true, inverse_of: :inventory_units
+    belongs_to :return_authorization, class_name: "Spree::ReturnAuthorization", inverse_of: :inventory_units
+    belongs_to :carton, class_name: "Spree::Carton", inverse_of: :inventory_units
+    belongs_to :line_item, class_name: "Spree::LineItem", inverse_of: :inventory_units
+
+    has_many :return_items, inverse_of: :inventory_unit, dependent: :destroy
+    has_one :original_return_item, class_name: "Spree::ReturnItem", foreign_key: :exchange_inventory_unit_id, dependent: :destroy
+    has_one :unit_cancel, class_name: "Spree::UnitCancel"
+
+    validates_presence_of :order, :shipment, :line_item, :variant
+
+    before_destroy :ensure_no_return_items
+
+    scope :backordered, -> { where state: 'backordered' }
+    scope :on_hand, -> { where state: 'on_hand' }
+    scope :pre_shipment, -> { where(state: PRE_SHIPMENT_STATES) }
+    scope :shipped, -> { where state: 'shipped' }
+    scope :post_shipment, -> { where(state: POST_SHIPMENT_STATES) }
+    scope :returned, -> { where state: 'returned' }
+    scope :canceled, -> { where(state: 'canceled') }
+    scope :not_canceled, -> { where.not(state: 'canceled') }
+    scope :cancelable, -> { where(state: Spree::InventoryUnit::CANCELABLE_STATES) }
+    scope :backordered_per_variant, ->(stock_item) do
+      includes(:shipment, :order)
+        .where("spree_shipments.state != 'canceled'").references(:shipment)
+        .where(variant_id: stock_item.variant_id)
+        .where('spree_orders.completed_at is not null')
+        .backordered.order("spree_orders.completed_at ASC")
+    end
+    scope :shippable, -> { on_hand }
+
+    # state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
+    state_machine initial: :on_hand do
+      event :fill_backorder do
+        transition to: :on_hand, from: :backordered
+      end
+      after_transition on: :fill_backorder, do: :fulfill_order
+
+      event :ship do
+        transition to: :shipped, if: :allow_ship?
+      end
+
+      event :return do
+        transition to: :returned, from: :shipped
+      end
+
+      event :cancel do
+        transition to: :canceled, from: CANCELABLE_STATES.map(&:to_sym)
+      end
+    end
+
+    # @param stock_item [Spree::StockItem] the stock item of the desired
+    #   inventory units
+    # @return [Array<Spree::InventoryUnit>] an array of backordered inventory
+    #   units for the given stock item
+    def self.backordered_for_stock_item(stock_item)
+      # This was refactored from a simpler query because the previous
+      # implementation led to issues once users tried to modify the objects
+      # returned. That's due to ActiveRecord `joins(shipment: :stock_location)`
+      # only returning readonly objects
+      backordered_per_variant(stock_item).select do |unit|
+        unit.shipment.stock_location == stock_item.stock_location
+      end
+    end
+
+    # Updates the given inventory units to not be pending.
+    #
+    # @param inventory_units [<Spree::InventoryUnit>] the inventory to be
+    #   finalized
+    def self.finalize_units!(inventory_units)
+      inventory_units.map do |iu|
+        iu.update_columns(
+          pending: false,
+          updated_at: Time.now,
+        )
+      end
+    end
+
+    # @return [Spree::StockItem] the first stock item from this shipment's
+    #   stock location that is associated with this inventory unit's variant
+    def find_stock_item
+      Spree::StockItem.where(stock_location_id: shipment.stock_location_id,
+        variant_id: variant_id).first
+    end
+
+    # @note This returns the variant regardless of whether it was soft
+    #   deleted.
+    # @return [Spree::Variant] this inventory unit's variant.
+    def variant
+      Spree::Variant.unscoped { super }
+    end
+
+    # @return [Spree::ReturnItem] a valid return item for this inventory unit
+    #   if one exists, or a new one if one does not
+    def current_or_new_return_item
+      Spree::ReturnItem.from_inventory_unit(self)
+    end
+
+    # @return [BigDecimal] the portion of the additional tax on the line item
+    #   this inventory unit belongs to that is associated with this individual
+    #   inventory unit
+    def additional_tax_total
+      line_item.additional_tax_total * percentage_of_line_item
+    end
+
+    # @return [BigDecimal] the portion of the included tax on the line item
+    #   this inventory unit belongs to that is associated with this
+    #   individual inventory unit
+    def included_tax_total
+      line_item.included_tax_total * percentage_of_line_item
+    end
+
+    # @return [Boolean] true if this inventory unit has any return items
+    #   which have requested exchanges
+    def exchange_requested?
+      return_items.not_expired.any?(&:exchange_requested?)
+    end
+
+    private
+
+      def allow_ship?
+        self.on_hand?
+      end
+
+      def fulfill_order
+        self.reload
+        order.fulfill!
+      end
+
+      def percentage_of_line_item
+        1 / BigDecimal.new(line_item.quantity)
+      end
+
+      def current_return_item
+        return_items.not_cancelled.first
+      end
+
+      # If an inventory unit is associated with return items and really needs
+      # to be deleted then explicitly delete the associated return items first.
+      def ensure_no_return_items
+        if return_items.exists?
+          raise "Inventory units associated with return items should not be deleted."
+        end
+      end
+  end
+end