solidus_core 1.0.0.pre

data/app/models/spree/calculator/shipping/flexi_rate.rb

@@ -0,0 +1,35 @@
+require_dependency 'spree/shipping_calculator'
+
+module Spree
+  module Calculator::Shipping
+    class FlexiRate < ShippingCalculator
+      preference :first_item,      :decimal, default: 0.0
+      preference :additional_item, :decimal, default: 0.0
+      preference :max_items,       :integer, default: 0
+      preference :currency,        :string,  default: ->{ Spree::Config[:currency] }
+
+      def self.description
+        Spree.t(:shipping_flexible_rate)
+      end
+
+      def compute_package(package)
+        compute_from_quantity(package.contents.sum(&:quantity))
+      end
+
+      def compute_from_quantity(quantity)
+        sum = 0
+        max = self.preferred_max_items.to_i
+        quantity.times do |i|
+          # check max value to avoid divide by 0 errors
+          if (max == 0 && i == 0) || (max > 0) && (i % max == 0)
+            sum += self.preferred_first_item.to_f
+          else
+            sum += self.preferred_additional_item.to_f
+          end
+        end
+
+        sum
+      end
+    end
+  end
+end

data/app/models/spree/calculator/shipping/per_item.rb

@@ -0,0 +1,22 @@
+require_dependency 'spree/shipping_calculator'
+
+module Spree
+  module Calculator::Shipping
+    class PerItem < ShippingCalculator
+      preference :amount, :decimal, default: 0
+      preference :currency, :string, default: ->{ Spree::Config[:currency] }
+
+      def self.description
+        Spree.t(:shipping_flat_rate_per_item)
+      end
+
+      def compute_package(package)
+        compute_from_quantity(package.contents.sum(&:quantity))
+      end
+
+      def compute_from_quantity(quantity)
+        self.preferred_amount * quantity
+      end
+    end
+  end
+end

data/app/models/spree/calculator/shipping/price_sack.rb

@@ -0,0 +1,28 @@
+require_dependency 'spree/shipping_calculator'
+
+module Spree
+  module Calculator::Shipping
+    class PriceSack < ShippingCalculator
+      preference :minimal_amount, :decimal, default: 0
+      preference :normal_amount, :decimal, default: 0
+      preference :discount_amount, :decimal, default: 0
+      preference :currency, :string, default: ->{ Spree::Config[:currency] }
+
+      def self.description
+        Spree.t(:shipping_price_sack)
+      end
+
+      def compute_package(package)
+        compute_from_price(total(package.contents))
+      end
+
+      def compute_from_price(price)
+        if price < self.preferred_minimal_amount
+          self.preferred_normal_amount
+        else
+          self.preferred_discount_amount
+        end
+      end
+    end
+  end
+end

data/app/models/spree/calculator/tiered_flat_rate.rb

@@ -0,0 +1,37 @@
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::TieredFlatRate < Calculator
+    preference :base_amount, :decimal, default: 0
+    preference :tiers, :hash, default: {}
+
+    before_validation do
+      # Convert tier values to decimals. Strings don't do us much good.
+      if preferred_tiers.is_a?(Hash)
+        self.preferred_tiers = Hash[*preferred_tiers.flatten.map(&:to_f)]
+      end
+    end
+
+    validate :preferred_tiers_content
+
+    def self.description
+      Spree.t(:tiered_flat_rate)
+    end
+
+    def compute(object)
+      base, amount = preferred_tiers.sort.reverse.detect{ |b,_| object.amount >= b }
+      amount || preferred_base_amount
+    end
+
+    private
+    def preferred_tiers_content
+      if preferred_tiers.is_a? Hash
+        unless preferred_tiers.keys.all?{ |k| k.is_a?(Numeric) && k > 0 }
+          errors.add(:base, :keys_should_be_positive_number)
+        end
+      else
+        errors.add(:preferred_tiers, :should_be_hash)
+      end
+    end
+  end
+end

data/app/models/spree/calculator/tiered_percent.rb

@@ -0,0 +1,44 @@
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::TieredPercent < Calculator
+    preference :base_percent, :decimal, default: 0
+    preference :tiers, :hash, default: {}
+
+    before_validation do
+      # Convert tier values to decimals. Strings don't do us much good.
+      if preferred_tiers.is_a?(Hash)
+        self.preferred_tiers = Hash[*preferred_tiers.flatten.map(&:to_f)]
+      end
+    end
+
+    validates :preferred_base_percent, numericality: {
+      greater_than_or_equal_to: 0,
+      less_than_or_equal_to: 100
+    }
+    validate :preferred_tiers_content
+
+    def self.description
+      Spree.t(:tiered_percent)
+    end
+
+    def compute(object)
+      base, percent = preferred_tiers.sort.reverse.detect{ |b,_| object.amount >= b }
+      (object.amount * (percent || preferred_base_percent) / 100).round(2)
+    end
+
+    private
+    def preferred_tiers_content
+      if preferred_tiers.is_a? Hash
+        unless preferred_tiers.keys.all?{ |k| k.is_a?(Numeric) && k > 0 }
+          errors.add(:base, :keys_should_be_positive_number)
+        end
+        unless preferred_tiers.values.all?{ |k| k.is_a?(Numeric) && k >= 0 && k <= 100 }
+          errors.add(:base, :values_should_be_percent)
+        end
+      else
+        errors.add(:preferred_tiers, :should_be_hash)
+      end
+    end
+  end
+end

data/app/models/spree/carton.rb

@@ -0,0 +1,57 @@
+class Spree::Carton < ActiveRecord::Base
+  belongs_to :address, class_name: 'Spree::Address', inverse_of: :cartons
+  belongs_to :stock_location, class_name: 'Spree::StockLocation', inverse_of: :cartons
+  belongs_to :shipping_method, class_name: 'Spree::ShippingMethod', inverse_of: :cartons
+
+  has_many :inventory_units, inverse_of: :carton
+  has_many :orders, -> { uniq }, through: :inventory_units
+  has_many :shipments, -> { uniq }, through: :inventory_units
+
+  validates :address, presence: true
+  validates :stock_location, presence: true
+  validates :shipping_method, presence: true
+  validates :inventory_units, presence: true
+  validates :shipped_at, presence: true
+
+  make_permalink field: :number, length: 11, prefix: 'C'
+
+  scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }
+  # sort by most recent shipped_at, falling back to created_at. add "id desc" to make specs that involve this scope more deterministic.
+  scope :reverse_chronological, -> { order(shipped_at: :desc, id: :desc) }
+
+  def to_param
+    number
+  end
+
+  def tracking_url
+    @tracking_url ||= shipping_method.build_tracking_url(tracking)
+  end
+
+  def order_numbers
+    orders.map(&:number)
+  end
+
+  def order_emails
+    orders.map(&:email).uniq
+  end
+
+  def shipment_numbers
+    shipments.map(&:number)
+  end
+
+  def display_shipped_at
+    shipped_at.to_s(:rfc822)
+  end
+
+  def manifest
+    @manifest ||= Spree::ShippingManifest.new(inventory_units: inventory_units).items
+  end
+
+  def manifest_for_order(order)
+    Spree::ShippingManifest.new(inventory_units: (inventory_units & order.inventory_units)).items
+  end
+
+  def any_exchanges?
+    inventory_units.any?(&:original_return_item)
+  end
+end

data/app/models/spree/classification.rb

@@ -0,0 +1,11 @@
+module Spree
+  class Classification < Spree::Base
+    self.table_name = 'spree_products_taxons'
+    acts_as_list scope: :taxon
+    belongs_to :product, class_name: "Spree::Product", inverse_of: :classifications
+    belongs_to :taxon, class_name: "Spree::Taxon", inverse_of: :classifications, touch: true
+
+    # For #3494
+    validates_uniqueness_of :taxon_id, scope: :product_id, message: :already_linked
+  end
+end

data/app/models/spree/country.rb

@@ -0,0 +1,23 @@
+module Spree
+  class Country < Spree::Base
+    has_many :states, -> { order('name ASC') }, dependent: :destroy
+    has_many :addresses, dependent: :nullify
+
+    validates :name, :iso_name, presence: true
+
+    def self.states_required_by_country_id
+      ActiveSupport::Deprecation.warn "Spree::Country.states_required_by_country_id is deprecated and will be removed from future releases, Implement it yourself.", caller
+      states_required = Hash.new(true)
+      all.each { |country| states_required[country.id.to_s]= country.states_required }
+      states_required
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/app/models/spree/credit_card.rb

@@ -0,0 +1,197 @@
+module Spree
+  class CreditCard < Spree::Base
+    belongs_to :payment_method
+    belongs_to :user, class_name: Spree.user_class, foreign_key: 'user_id'
+    has_many :payments, as: :source
+
+    before_save :set_last_digits
+
+    after_save :ensure_one_default
+
+    attr_accessor :encrypted_data,
+                    :number,
+                    :imported,
+                    :verification_value
+
+    validates :month, :year, numericality: { only_integer: true }, if: :require_card_numbers?, on: :create
+    validates :number, presence: true, if: :require_card_numbers?, on: :create, unless: :imported
+    validates :name, presence: true, if: :require_card_numbers?, on: :create
+    validates :verification_value, presence: true, if: :require_card_numbers?, on: :create, unless: :imported
+
+    validate :expiry_not_in_the_past
+
+    scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
+    scope :default, -> { where(default: true) }
+
+    # needed for some of the ActiveMerchant gateways (eg. SagePay)
+    alias_attribute :brand, :cc_type
+
+    CARD_TYPES = {
+      visa: /^4[0-9]{12}(?:[0-9]{3})?$/,
+      master: /(^5[1-5][0-9]{14}$)|(^6759[0-9]{2}([0-9]{10})$)|(^6759[0-9]{2}([0-9]{12})$)|(^6759[0-9]{2}([0-9]{13})$)/,
+      diners_club: /^3(?:0[0-5]|[68][0-9])[0-9]{11}$/,
+      american_express: /^3[47][0-9]{13}$/,
+      discover: /^6(?:011|5[0-9]{2})[0-9]{12}$/,
+      jcb: /^(?:2131|1800|35\d{3})\d{11}$/
+    }
+
+    # Sets the expiry date on this credit card.
+    #
+    # @param expiry [String] the desired new expiry date in one of the
+    #   following formats: "mm/yy", "mm / yyyy", "mmyy", "mmyyyy"
+    def expiry=(expiry)
+      return unless expiry.present?
+
+      self[:month], self[:year] =
+      if expiry.match(/\d{2}\s?\/\s?\d{2,4}/) # will match mm/yy and mm / yyyy
+        expiry.delete(' ').split('/')
+      elsif match = expiry.match(/(\d{2})(\d{2,4})/) # will match mmyy and mmyyyy
+        [match[1], match[2]]
+      end
+      if self[:year]
+        self[:year] = "20" + self[:year] if self[:year].length == 2
+        self[:year] = self[:year].to_i
+      end
+      self[:month] = self[:month].to_i if self[:month]
+    end
+
+    # Sets the credit card number, removing any non-numeric characters.
+    #
+    # @param num [String] the desired credit card number
+    def number=(num)
+      @number = num.gsub(/[^0-9]/, '') rescue nil
+    end
+
+    # Sets the credit card type, converting it to the preferred internal
+    # representation from jquery.payment's representation when appropriate.
+    #
+    # @param type [String] the desired credit card type
+    def cc_type=(type)
+      # cc_type is set by jquery.payment, which helpfully provides different
+      # types from Active Merchant. Converting them is necessary.
+      self[:cc_type] = case type
+      when 'mastercard', 'maestro' then 'master'
+      when 'amex' then 'american_express'
+      when 'dinersclub' then 'diners_club'
+      when '' then try_type_from_number
+      else type
+      end
+    end
+
+    # Sets the last digits field based on the assigned credit card number.
+    def set_last_digits
+      number.to_s.gsub!(/\s/,'')
+      verification_value.to_s.gsub!(/\s/,'')
+      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
+    end
+
+    # @return [String] the credit card type if it can be determined from the
+    #   number, otherwise the empty string
+    def try_type_from_number
+      numbers = number.delete(' ') if number
+      CARD_TYPES.find{|type, pattern| return type.to_s if numbers =~ pattern}.to_s
+    end
+
+    # @return [Boolean] true when a verification value is present
+    def verification_value?
+      verification_value.present?
+    end
+
+    # @return [String] the card number, with all but last 4 numbers replace
+    #   with "X", as in "XXXX-XXXX-XXXX-4338"
+    def display_number
+      "XXXX-XXXX-XXXX-#{last_digits}"
+    end
+
+    # @return [Array<String>] the actions available on this credit card
+    def actions
+      %w{capture void credit}
+    end
+
+    # @param payment [Spree::Payment] the payment we want to know if can be captured
+    # @return [Boolean] true when the payment is in the pending or checkout states
+    def can_capture?(payment)
+      payment.pending? || payment.checkout?
+    end
+
+    # @param payment [Spree::Payment] the payment we want to know if can be voided
+    # @return [Boolean] true when the payment is not failed or voided
+    def can_void?(payment)
+      !payment.failed? && !payment.void?
+    end
+
+    # Indicates whether its possible to credit the payment.  Note that most
+    # gateways require that the payment be settled first which generally
+    # happens within 12-24 hours of the transaction.
+    #
+    # @param payment [Spree::Payment] the payment we want to know if can be credited
+    # @return [Boolean] true when the payment is completed and can be credited
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed > 0
+    end
+
+    # @return [Boolean] true when there is a gateway customer or payment
+    #   profile id present
+    def has_payment_profile?
+      gateway_customer_profile_id.present? || gateway_payment_profile_id.present?
+    end
+
+    # @note ActiveMerchant needs first_name/last_name because we pass it a
+    #   Spree::CreditCard and it calls those methods on it.
+    # @todo We should probably be calling #to_active_merchant before passing
+    #   the object to ActiveMerchant.
+    # @return [String] the first name on this credit card
+    def first_name
+      name.to_s.split(/[[:space:]]/, 2)[0]
+    end
+
+    # @note ActiveMerchant needs first_name/last_name because we pass it a
+    #   Spree::CreditCard and it calls those methods on it.
+    # @todo We should probably be calling #to_active_merchant before passing
+    #   the object to ActiveMerchant.
+    # @return [String] the last name on this credit card
+    def last_name
+      name.to_s.split(/[[:space:]]/, 2)[1]
+    end
+
+    # @return [ActiveMerchant::Billing::CreditCard] an ActiveMerchant credit
+    #   card that represents this credit card
+    def to_active_merchant
+      ActiveMerchant::Billing::CreditCard.new(
+        :number => number,
+        :month => month,
+        :year => year,
+        :verification_value => verification_value,
+        :first_name => first_name,
+        :last_name => last_name,
+      )
+    end
+
+    private
+
+    def expiry_not_in_the_past
+      if year.present? && month.present?
+        if month.to_i < 1 || month.to_i > 12
+          errors.add(:base, :expiry_invalid)
+        else
+          current = Time.current
+          if year.to_i < current.year or (year.to_i == current.year and month.to_i < current.month)
+            errors.add(:base, :card_expired)
+          end
+        end
+      end
+    end
+
+    def require_card_numbers?
+      !self.encrypted_data.present? && !self.has_payment_profile?
+    end
+
+    def ensure_one_default
+      if self.user_id && self.default
+        CreditCard.where(default: true).where.not(id: self.id).where(user_id: self.user_id).each do |ucc|
+          ucc.update_columns(default: false, updated_at: Time.now)
+        end
+      end
+    end
+  end
+end