goca-spree-core 3.1.14.rails.5.0

data/app/models/concerns/spree/user_api_authentication.rb

@@ -0,0 +1,19 @@
+module Spree
+  module UserApiAuthentication
+    def generate_spree_api_key!
+      self.spree_api_key = generate_spree_api_key
+      save!
+    end
+
+    def clear_spree_api_key!
+      self.spree_api_key = nil
+      save!
+    end
+
+    private
+
+    def generate_spree_api_key
+      SecureRandom.hex(24)
+    end
+  end
+end

data/app/models/concerns/spree/user_methods.rb

@@ -0,0 +1,57 @@
+module Spree
+  module UserMethods
+    extend ActiveSupport::Concern
+
+    include Spree::UserApiAuthentication
+    include Spree::UserPaymentSource
+    include Spree::UserReporting
+    include Spree::RansackableAttributes
+
+    included do
+      # we need to have this callback before any dependent: :destroy associations
+      # https://github.com/rails/rails/issues/3458
+      before_destroy :check_completed_orders
+
+      has_many :role_users, class_name: 'Spree::RoleUser', foreign_key: :user_id, dependent: :destroy
+      has_many :spree_roles, through: :role_users, class_name: 'Spree::Role', source: :role
+
+      has_many :promotion_rule_users, class_name: 'Spree::PromotionRuleUser', foreign_key: :user_id, dependent: :destroy
+      has_many :promotion_rules, through: :promotion_rule_users, class_name: 'Spree::PromotionRule'
+
+      has_many :orders, foreign_key: :user_id, class_name: "Spree::Order"
+      has_many :store_credits, foreign_key: :user_id, class_name: 'Spree::StoreCredit'
+
+      belongs_to :ship_address, class_name: 'Spree::Address'
+      belongs_to :bill_address, class_name: 'Spree::Address'
+
+      self.whitelisted_ransackable_associations = %w[bill_address ship_address]
+      self.whitelisted_ransackable_attributes = %w[id email]
+    end
+
+    # has_spree_role? simply needs to return true or false whether a user has a role or not.
+    def has_spree_role?(role_in_question)
+      spree_roles.any? { |role| role.name == role_in_question.to_s }
+    end
+
+    def last_incomplete_spree_order
+      orders.incomplete.
+        includes(line_items: [variant: [:images, :option_values, :product]]).
+        order('created_at DESC').
+        first
+    end
+
+    def analytics_id
+      id
+    end
+
+    def total_available_store_credit
+      store_credits.reload.to_a.sum(&:amount_remaining)
+    end
+
+    private
+
+    def check_completed_orders
+      raise Spree::Core::DestroyWithOrdersError if orders.complete.present?
+    end
+  end
+end

data/app/models/concerns/spree/user_payment_source.rb

@@ -0,0 +1,19 @@
+module Spree
+  module UserPaymentSource
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :credit_cards, class_name: "Spree::CreditCard", foreign_key: :user_id
+      def default_credit_card; credit_cards.default.first; end
+
+      def payment_sources
+        credit_cards.with_payment_profile
+      end
+
+      def drop_payment_source(source)
+        gateway = source.payment_method
+        gateway.disable_customer_profile(source)
+      end
+    end
+  end
+end

data/app/models/concerns/spree/user_reporting.rb

@@ -0,0 +1,22 @@
+module Spree
+  module UserReporting
+    extend DisplayMoney
+    money_methods :lifetime_value, :average_order_value
+
+    def lifetime_value
+      orders.complete.sum(:total)
+    end
+
+    def order_count
+      BigDecimal(orders.complete.size)
+    end
+
+    def average_order_value
+      if order_count.to_i > 0
+        lifetime_value / order_count
+      else
+        BigDecimal("0.00")
+      end
+    end
+  end
+end

data/app/models/concerns/spree/vat_price_calculation.rb

@@ -0,0 +1,47 @@
+module Spree
+  module VatPriceCalculation
+    def gross_amount(amount, price_options)
+      return amount unless outside_default_vat_zone?(price_options)
+      round_to_two_places(add_foreign_vat_for(amount, price_options))
+    end
+
+    private
+
+    def add_foreign_vat_for(amount, price_options)
+      amount = net_amount(amount, price_options[:tax_category])
+      amount_with_foreign_vat(amount, price_options)
+    end
+
+    def net_amount(amount, tax_category)
+      amount / (1 + default_vat(tax_category))
+    end
+
+    def default_vat(tax_category)
+      included_tax_amount(tax_zone: default_zone, tax_category: tax_category)
+    end
+
+    def foreign_vat(price_options)
+      included_tax_amount(price_options)
+    end
+
+    def amount_with_foreign_vat(amount, price_options)
+      amount * (1 + foreign_vat(price_options))
+    end
+
+    def outside_default_vat_zone?(price_options)
+      price_options[:tax_zone] && default_zone && price_options[:tax_zone] != default_zone
+    end
+
+    def included_tax_amount(price_options)
+      Spree::TaxRate.included_tax_amount_for(price_options).to_f
+    end
+
+    def default_zone
+      @_default_zone ||= Spree::Zone.default_tax
+    end
+
+    def round_to_two_places(amount)
+      BigDecimal.new(amount.to_s).round(2, BigDecimal::ROUND_HALF_UP)
+    end
+  end
+end

data/app/models/friendly_id/slug_decorator.rb

@@ -0,0 +1,3 @@
+FriendlyId::Slug.class_eval do
+  acts_as_paranoid
+end

data/app/models/spree/ability.rb

@@ -0,0 +1,80 @@
+# Implementation class for Cancan gem.  Instead of overriding this class, consider adding new permissions
+# using the special +register_ability+ method which allows extensions to add their own abilities.
+#
+# See http://github.com/ryanb/cancan for more details on cancan.
+require 'cancan'
+module Spree
+  class Ability
+    include CanCan::Ability
+
+    class_attribute :abilities
+    self.abilities = Set.new
+
+    # Allows us to go beyond the standard cancan initialize method which makes it difficult for engines to
+    # modify the default +Ability+ of an application.  The +ability+ argument must be a class that includes
+    # the +CanCan::Ability+ module.  The registered ability should behave properly as a stand-alone class
+    # and therefore should be easy to test in isolation.
+    def self.register_ability(ability)
+      self.abilities.add(ability)
+    end
+
+    def self.remove_ability(ability)
+      self.abilities.delete(ability)
+    end
+
+    def initialize(user)
+      self.clear_aliased_actions
+
+      # override cancan default aliasing (we don't want to differentiate between read and index)
+      alias_action :delete, to: :destroy
+      alias_action :edit, to: :update
+      alias_action :new, to: :create
+      alias_action :new_action, to: :create
+      alias_action :show, to: :read
+      alias_action :index, :read, to: :display
+      alias_action :create, :update, :destroy, to: :modify
+
+      user ||= Spree.user_class.new
+
+      if user.respond_to?(:has_spree_role?) && user.has_spree_role?('admin')
+        can :manage, :all
+      else
+        can :display, Country
+        can :display, OptionType
+        can :display, OptionValue
+        can :create, Order
+        can [:read, :update], Order do |order, token|
+          order.user == user || order.guest_token && token == order.guest_token
+        end
+        can :display, CreditCard, user_id: user.id
+        can :display, Product
+        can :display, ProductProperty
+        can :display, Property
+        can :create, Spree.user_class
+        can [:read, :update, :destroy], Spree.user_class, id: user.id
+        can :display, State
+        can :display, Taxon
+        can :display, Taxonomy
+        can :display, Variant
+        can :display, Zone
+      end
+
+      # Include any abilities registered by extensions, etc.
+      Ability.abilities.merge(abilities_to_register).each do |clazz|
+        ability = clazz.send(:new, user)
+        @rules = rules + ability.send(:rules)
+      end
+
+      # Protect admin role
+      cannot [:update, :destroy], Role, name: ['admin']
+    end
+
+    private
+
+    # you can override this method to register your abilities
+    # this method has to return array of classes
+    def abilities_to_register
+      []
+    end
+  end
+end

data/app/models/spree/address.rb

@@ -0,0 +1,145 @@
+module Spree
+  class Address < Spree::Base
+    require 'twitter_cldr'
+
+    belongs_to :country, class_name: "Spree::Country"
+    belongs_to :state, class_name: "Spree::State"
+
+    has_many :shipments, inverse_of: :address
+
+    with_options presence: true do
+      validates :firstname, :lastname, :address1, :city, :country
+      validates :zipcode, if: :require_zipcode?
+      validates :phone, if: :require_phone?
+    end
+
+    validate :state_validate, :postal_code_validate
+
+    alias_attribute :first_name, :firstname
+    alias_attribute :last_name, :lastname
+
+    self.whitelisted_ransackable_attributes = %w[firstname lastname company]
+
+    def self.build_default
+      country = Spree::Country.find(Spree::Config[:default_country_id]) rescue Spree::Country.first
+      new(country: country)
+    end
+
+    def self.default(user = nil, kind = "bill")
+      if user && user_address = user.public_send(:"#{kind}_address")
+        user_address.clone
+      else
+        build_default
+      end
+    end
+
+    # Can modify an address if it's not been used in an order (but checkouts controller has finer control)
+    # def editable?
+    #   new_record? || (shipments.empty? && checkouts.empty?)
+    # end
+
+    def full_name
+      "#{firstname} #{lastname}".strip
+    end
+
+    def state_text
+      state.try(:abbr) || state.try(:name) || state_name
+    end
+
+    def same_as?(other)
+      return false if other.nil?
+      attributes.except('id', 'updated_at', 'created_at') == other.attributes.except('id', 'updated_at', 'created_at')
+    end
+
+    alias same_as same_as?
+
+    def to_s
+      "#{full_name}: #{address1}"
+    end
+
+    def clone
+      self.class.new(self.attributes.except('id', 'updated_at', 'created_at'))
+    end
+
+    def ==(other_address)
+      self_attrs = self.attributes
+      other_attrs = other_address.respond_to?(:attributes) ? other_address.attributes : {}
+
+      [self_attrs, other_attrs].each { |attrs| attrs.except!('id', 'created_at', 'updated_at') }
+
+      self_attrs == other_attrs
+    end
+
+    def empty?
+      attributes.except('id', 'created_at', 'updated_at', 'country_id').all? { |_, v| v.nil? }
+    end
+
+    # Generates an ActiveMerchant compatible address hash
+    def active_merchant_hash
+      {
+        name: full_name,
+        address1: address1,
+        address2: address2,
+        city: city,
+        state: state_text,
+        zip: zipcode,
+        country: country.try(:iso),
+        phone: phone
+      }
+    end
+
+    def require_phone?
+      true
+    end
+
+    def require_zipcode?
+      true
+    end
+
+    private
+      def state_validate
+        # Skip state validation without country (also required)
+        # or when disabled by preference
+        return if country.blank? || !Spree::Config[:address_requires_state]
+        return unless country.states_required
+
+        # ensure associated state belongs to country
+        if state.present?
+          if state.country == country
+            self.state_name = nil #not required as we have a valid state and country combo
+          else
+            if state_name.present?
+              self.state = nil
+            else
+              errors.add(:state, :invalid)
+            end
+          end
+        end
+
+        # ensure state_name belongs to country without states, or that it matches a predefined state name/abbr
+        if state_name.present?
+          if country.states.present?
+            states = country.states.find_all_by_name_or_abbr(state_name)
+
+            if states.size == 1
+              self.state = states.first
+              self.state_name = nil
+            else
+              errors.add(:state, :invalid)
+            end
+          end
+        end
+
+        # ensure at least one state field is populated
+        errors.add :state, :blank if state.blank? && state_name.blank?
+      end
+
+      def postal_code_validate
+        return if country.blank? || country.iso.blank? || !require_zipcode?
+        return if !TwitterCldr::Shared::PostalCodes.territories.include?(country.iso.downcase.to_sym)
+
+        postal_code = TwitterCldr::Shared::PostalCodes.for_territory(country.iso)
+        errors.add(:zipcode, :invalid) if !postal_code.valid?(zipcode.to_s.strip)
+      end
+  end
+end

data/app/models/spree/adjustable/adjuster/base.rb

@@ -0,0 +1,25 @@
+module Spree
+  module Adjustable
+    module Adjuster
+      class Base
+        def self.adjust(adjustable, totals)
+          new(adjustable, totals).update
+        end
+
+        def initialize(adjustable, totals)
+          @adjustable = adjustable
+          @totals = totals
+        end
+
+        def update
+          raise NotImplementedError, "Please implement 'update' in your adjuster: #{self.class.name}"
+        end
+
+        private
+
+        attr_reader :adjustable
+        delegate :adjustments, to: :adjustable
+      end
+    end
+  end
+end

data/app/models/spree/adjustable/adjuster/promotion.rb

@@ -0,0 +1,41 @@
+module Spree
+  module Adjustable
+    module Adjuster
+      class Promotion < Spree::Adjustable::Adjuster::Base
+        def update
+          promo_adjustments = adjustments.competing_promos.reload.map { |a| a.update!(adjustable) }
+          promos_total = promo_adjustments.compact.sum
+          choose_best_promo_adjustment unless promos_total == 0
+          promo_total = best_promo_adjustment.try(:amount).to_f if best_promo_adjustment.try(:promotion?)
+
+          update_totals(promo_total)
+        end
+
+        private
+
+        # Picks one (and only one) competing discount to be eligible for
+        # this order. This adjustment provides the most discount, and if
+        # two adjustments have the same amount, then it will pick the
+        # latest one.
+        def choose_best_promo_adjustment
+          if best_promo_adjustment
+            other_promotions = adjustments.competing_promos.where.not(id: best_promo_adjustment.id)
+            other_promotions.update_all(eligible: false)
+          end
+        end
+
+        def best_promo_adjustment
+          @best_promo_adjustment ||= begin
+            adjustments.competing_promos.eligible.reorder("amount ASC, created_at DESC, id DESC").first
+          end
+        end
+
+        def update_totals(promo_total)
+          promo_total ||= 0.0
+          @totals[:promo_total] = promo_total
+          @totals[:taxable_adjustment_total] += promo_total
+        end
+      end
+    end
+  end
+end

data/app/models/spree/adjustable/adjuster/tax.rb

@@ -0,0 +1,26 @@
+module Spree
+  module Adjustable
+    module Adjuster
+      class Tax < Spree::Adjustable::Adjuster::Base
+        def update
+          tax = adjustments.tax
+          included_tax_total = tax.is_included.reload.map(&:update!).compact.sum
+          additional_tax_total = tax.additional.reload.map(&:update!).compact.sum
+
+          update_totals(included_tax_total, additional_tax_total)
+        end
+
+        private
+
+        def adjustments
+          adjustable.try(:all_adjustments) || adjustable.adjustments
+        end
+
+        def update_totals(included_tax_total, additional_tax_total)
+          @totals[:included_tax_total] = included_tax_total
+          @totals[:additional_tax_total] = additional_tax_total
+        end
+      end
+    end
+  end
+end

data/app/models/spree/adjustable/adjustments_updater.rb

@@ -0,0 +1,47 @@
+module Spree
+  module Adjustable
+    class AdjustmentsUpdater
+      def self.update(adjustable)
+        new(adjustable).update
+      end
+
+      def initialize(adjustable)
+        @adjustable = adjustable
+        adjustable.reload if shipment? && adjustable.persisted?
+      end
+
+      def update
+        return unless @adjustable.persisted?
+
+        totals = {
+          non_taxable_adjustment_total: 0,
+          taxable_adjustment_total: 0
+        }
+        adjusters.each do |klass|
+          klass.adjust(@adjustable, totals)
+        end
+
+        persist_totals totals
+      end
+
+      private
+
+      def persist_totals(totals)
+        attributes = totals
+        attributes[:adjustment_total] = totals[:non_taxable_adjustment_total] +
+                                        totals[:taxable_adjustment_total] +
+                                        totals[:additional_tax_total]
+        attributes[:updated_at] = Time.current
+        @adjustable.update_columns(totals)
+      end
+
+      def shipment?
+        @adjustable.is_a?(Shipment)
+      end
+
+      def adjusters
+        Rails.application.config.spree.adjusters
+      end
+    end
+  end
+end

data/app/models/spree/adjustable/promotion_accumulator.rb

@@ -0,0 +1,75 @@
+module Spree
+  module Adjustable
+    class PromotionAccumulator
+      attr_reader :adjustments, :sources, :promotions
+
+      # Adds accumulator as an attribute of adjustable to
+      # avoid changing number of passed arguments to
+      # adjustment#update! and concequential methods
+      def self.add_to(adjustable)
+        class << adjustable
+          attr_accessor :promotion_accumulator
+        end
+
+        adjustable.promotion_accumulator = new(adjustable)
+      end
+
+      def initialize(adjustable)
+        @adjustable = adjustable
+        @adjustments, @sources, @promotions = [], [], []
+        all_adjustments.each { |a| add_adjustment(a) }
+      end
+
+      def add_adjustment(adjustment, opts = {})
+        return unless adjustment.promotion?
+        source = opts[:source] || adjustment.source
+        promotion = opts[:promotion] || source.promotion
+
+        add(adjustments, adjustment, adjustment.id)
+        add(sources, source, adjustment.source_id)
+        add(promotions, promotion, source.promotion_id)
+      end
+
+      def promotions_adjustments(promotion_id, adjustments = adjustments())
+        where(sources, promotion_id: promotion_id).map do |source|
+          where(adjustments, source_id: source.id)
+        end.flatten
+      end
+
+      def promo_total(*args)
+        promotions_adjustments(*args).map(&:amount).reduce(0, &:+)
+      end
+
+      def total_with_promotion(promotion_id)
+        amount + ship_total + promo_total(promotion_id)
+      end
+
+      def item_total_with_promotion(promotion_id)
+        amount + promo_total(promotion_id, item_adjustments)
+      end
+
+      private
+
+      attr_reader :adjustable
+      delegate :order, to: :adjustable
+      delegate :amount, :ship_total, to: :order
+
+      def all_adjustments
+        order.all_adjustments.promotion.includes(source: [:promotion]).where.
+          not("adjustable_id = ? AND adjustable_type = ?", adjustable.id, adjustable.class.to_s)
+      end
+
+      def add(array, object, id)
+        array << object if array.none? { |a| a.id == id }
+      end
+
+      def item_adjustments
+        adjustments.select { |a| a.adjustable_type != 'Spree::Shipment' }
+      end
+
+      def where(array, opts = {})
+        array.select { |a| opts.all? { |k, v| a.respond_to?(k) && a.send(k) == v } }
+      end
+    end
+  end
+end