solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/mailers/spree/promotion_code_batch_mailer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionCodeBatchMailer < Spree::BaseMailer
+    def promotion_code_batch_finished(promotion_code_batch)
+      @promotion_code_batch = promotion_code_batch
+      mail(to: promotion_code_batch.email)
+    end
+
+    def promotion_code_batch_errored(promotion_code_batch)
+      @promotion_code_batch = promotion_code_batch
+      mail(to: promotion_code_batch.email)
+    end
+  end
+end

data/app/mailers/spree/reimbursement_mailer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spree
+  class ReimbursementMailer < BaseMailer
+    def reimbursement_email(reimbursement, resend = false)
+      @reimbursement = reimbursement.respond_to?(:id) ? reimbursement : Spree::Reimbursement.find(reimbursement)
+      store = @reimbursement.order.store
+      subject = (resend ? "[#{t('spree.resend').upcase}] " : '')
+      subject += "#{store.name} #{t('.subject')} ##{@reimbursement.order.number}"
+      mail(to: @reimbursement.order.email, from: from_address(store), subject: subject)
+    end
+  end
+end

data/app/mailers/spree/test_mailer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Spree
+  class TestMailer < BaseMailer
+    def test_email(email)
+      store = Spree::Store.default
+      subject = "#{store.name} #{t('.subject')}"
+      mail(to: email, from: from_address(store), subject: subject)
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Spree
+  module AdjustmentSource
+    def deals_with_adjustments_for_deleted_source
+      Spree::Deprecation.warn "AdjustmentSource#deals_with_adjustments_for_deleted_source is deprecated. Please use AdjustmentSource#remove_adjustments_from_incomplete_orders instead."
+
+      remove_adjustments_from_incomplete_orders
+
+      # The following is deprecated. As source_type without a source_id isn't
+      # much better than a source_id that doesn't exist.  In Solidus itself the
+      # relevant classes use `acts_as_paranoid` so it is useful to keep the
+      # source_id around.
+      adjustments.
+        joins(:order).
+        merge(Spree::Order.complete).
+        update_all(source_id: nil, updated_at: Time.current)
+    end
+
+    def remove_adjustments_from_incomplete_orders
+      adjustments.
+        joins(:order).
+        merge(Spree::Order.incomplete).
+        destroy_all
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Spree
+  module CalculatedAdjustments
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :calculator, class_name: "Spree::Calculator", as: :calculable, inverse_of: :calculable, dependent: :destroy, autosave: true
+      accepts_nested_attributes_for :calculator, update_only: true
+      validates :calculator, presence: true
+    end
+
+    class_methods do
+      def calculators
+        Spree::Deprecation.warn("Calling .calculators is deprecated. Please access through Rails.application.config.spree.calculators")
+
+        spree_calculators.send model_name_without_spree_namespace
+      end
+
+      private
+
+      def model_name_without_spree_namespace
+        to_s.tableize.tr('/', '_').sub('spree_', '')
+      end
+
+      def spree_calculators
+        Spree::Config.environment.calculators
+      end
+    end
+
+    def calculator_type
+      calculator.class.to_s if calculator
+    end
+
+    def calculator_type=(calculator_type)
+      klass = calculator_type.constantize if calculator_type
+      self.calculator = klass.new if klass && !calculator.instance_of?(klass)
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Spree
+  module DefaultPrice
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :default_price,
+        -> { with_deleted.currently_valid.with_default_attributes },
+        class_name: 'Spree::Price',
+        inverse_of: :variant,
+        dependent: :destroy,
+        autosave: true
+    end
+
+    def find_or_build_default_price
+      default_price || build_default_price(Spree::Config.default_pricing_options.desired_attributes)
+    end
+
+    delegate :display_price, :display_amount, :price, to: :find_or_build_default_price
+    delegate :price=, to: :find_or_build_default_price
+
+    def has_default_price?
+      !default_price.nil?
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Spree
+  module DisplayMoney
+    ##
+    # Takes a list of methods that the base object wants to be able to use
+    # to display with Spree::Money, and turns them into display_* methods.
+    # Intended to help clean up some of the presentational logic that exists
+    # at the model layer.
+    #
+    #
+    # ==== Examples
+    # Decorate a method, with the default option of using the base object's
+    # currency
+    #
+    #     extend Spree::DisplayMoney
+    #     money_methods :tax_amount, :price
+    #
+    # Decorate a method, but with some additional options
+    #     extend Spree::DisplayMoney
+    #     money_methods tax_amount: { currency: "CAD", no_cents: true }, :price
+    def money_methods(*args)
+      args.each do |money_method|
+        money_method = { money_method => {} } unless money_method.is_a? Hash
+        money_method.each do |method_name, opts|
+          define_method("display_#{method_name}") do
+            default_opts = respond_to?(:currency) ? { currency: currency } : {}
+            Spree::Money.new(send(method_name), default_opts.merge(opts))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Spree
+  module NamedType
+    extend ActiveSupport::Concern
+
+    included do
+      scope :active, -> { where(active: true) }
+      default_scope -> { order(arel_table[:name].lower) }
+
+      validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Spree
+  module OrderedPropertyValueList
+    extend ActiveSupport::Concern
+
+    included do
+      validates :property, presence: true
+      validates_with Spree::Validations::DbMaximumLengthValidator, field: :value
+
+      default_scope -> { order(:position) }
+    end
+
+    # virtual attributes for use with AJAX autocompletion
+    def property_name
+      property.name if property
+    end
+
+    def property_name=(name)
+      unless name.blank?
+        unless property = Spree::Property.find_by(name: name)
+          property = Spree::Property.create(name: name, presentation: name)
+        end
+        self.property = property
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Spree::RansackableAttributes
+  extend ActiveSupport::Concern
+  included do
+    class_attribute :whitelisted_ransackable_associations
+    class_attribute :whitelisted_ransackable_attributes
+
+    class_attribute :default_ransackable_attributes
+    self.default_ransackable_attributes = %w[id name]
+  end
+
+  class_methods do
+    def ransackable_associations(*_args)
+      whitelisted_ransackable_associations || []
+    end
+
+    def ransackable_attributes(*_args)
+      default_ransackable_attributes | (whitelisted_ransackable_attributes || [])
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Spree
+  module UserAddressBook
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :user_addresses, -> { active }, { foreign_key: "user_id", class_name: "Spree::UserAddress" } do
+        def find_first_by_address_values(address_attrs)
+          detect { |ua| ua.address == Spree::Address.new(address_attrs) }
+        end
+
+        # @note this method enforces only one default address per user
+        def mark_default(user_address)
+          # the checks of persisted? allow us to build a User and associate Addresses at once
+          ActiveRecord::Base.transaction do
+            (self - [user_address]).each do |ua| # update_all would be nice, but it bypasses ActiveRecord callbacks
+              ua.persisted? ? ua.update!(default: false) : ua.default = false
+            end
+            user_address.persisted? ? user_address.update!(default: true, archived: false) : user_address.default = true
+          end
+        end
+      end
+
+      has_many :addresses, through: :user_addresses
+
+      # bill_address is only minimally used now, but we can't get rid of it without a major version release
+      belongs_to :bill_address, class_name: 'Spree::Address'
+
+      has_one :default_user_address, ->{ default }, class_name: 'Spree::UserAddress', foreign_key: 'user_id'
+      has_one :default_address, through: :default_user_address, source: :address
+      alias_method :ship_address, :default_address
+    end
+
+    def bill_address=(address)
+      # stow a copy in our address book too
+      address = save_in_address_book(address.attributes) if address
+      super(address)
+    end
+
+    def bill_address_attributes=(attributes)
+      self.bill_address = Spree::Address.immutable_merge(bill_address, attributes)
+    end
+
+    def default_address=(address)
+      save_in_address_book(address.attributes, true) if address
+    end
+
+    def default_address_attributes=(attributes)
+      # see "Nested Attributes Examples" section of http://apidock.com/rails/ActionView/Helpers/FormHelper/fields_for
+      # this #{fieldname}_attributes= method works with fields_for in the views
+      # even without declaring accepts_nested_attributes_for
+      self.default_address = Spree::Address.immutable_merge(default_address, attributes)
+    end
+
+    alias_method :ship_address_attributes=, :default_address_attributes=
+
+    # saves address in address book
+    # sets address to the default if automatic_default_address is set to true
+    # if address is nil, does nothing and returns nil
+    def ship_address=(address)
+      be_default = Spree::Config.automatic_default_address
+      save_in_address_book(address.attributes, be_default) if address
+    end
+
+    # saves order.ship_address and order.bill_address in address book
+    # sets ship_address to the default if automatic_default_address is set to true
+    # sets bill_address to the default if automatic_default_address is set to true and there is no ship_address
+    # if one address is nil, does not save that address
+    def persist_order_address(order)
+      if order.ship_address
+        address = save_in_address_book(
+          order.ship_address.attributes,
+          Spree::Config.automatic_default_address
+        )
+        self.ship_address_id = address.id if address && address.persisted?
+      end
+
+      if order.bill_address
+        address = save_in_address_book(
+          order.bill_address.attributes,
+          order.ship_address.nil? && Spree::Config.automatic_default_address
+        )
+        self.bill_address_id = address.id if address && address.persisted?
+      end
+
+      save! # In case the ship_address_id or bill_address_id was set
+    end
+
+    # Add an address to the user's list of saved addresses for future autofill
+    # @param address_attributes HashWithIndifferentAccess of attributes that will be
+    # treated as value equality to de-dup among existing Addresses
+    # @param default set whether or not this address will show up from
+    # #default_address or not
+    def save_in_address_book(address_attributes, default = false)
+      return nil unless address_attributes.present?
+      address_attributes = address_attributes.to_h.with_indifferent_access
+
+      new_address = Spree::Address.factory(address_attributes)
+      return new_address unless new_address.valid?
+
+      first_one = user_addresses.empty?
+
+      if address_attributes[:id].present? && new_address.id != address_attributes[:id]
+        remove_from_address_book(address_attributes[:id])
+      end
+
+      user_address = prepare_user_address(new_address)
+      user_addresses.mark_default(user_address) if default || first_one
+
+      if persisted?
+        user_address.save!
+
+        # If these associations have already been accessed, they will be
+        # caching the existing values.
+        # user_addresses need to be reset to get the new ordering based on any changes
+        # {default_,}user_address needs to be reset as its result is likely to have changed.
+        user_addresses.reset
+        association(:default_user_address).reset
+        association(:default_address).reset
+      end
+
+      user_address.address
+    end
+
+    def mark_default_address(address)
+      user_addresses.mark_default(user_addresses.find_by(address: address))
+    end
+
+    def remove_from_address_book(address_id)
+      user_address = user_addresses.find_by(address_id: address_id)
+      if user_address
+        user_address.update_attributes(archived: true, default: false)
+      else
+        false
+      end
+    end
+
+    private
+
+    def prepare_user_address(new_address)
+      user_address = user_addresses.all_historical.find_first_by_address_values(new_address.attributes)
+      user_address ||= user_addresses.build
+      user_address.address = new_address
+      user_address.archived = false
+      user_address
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Spree
+  module UserMethods
+    extend ActiveSupport::Concern
+
+    include Spree::UserReporting
+    include Spree::UserAddressBook
+    include Spree::UserPaymentSource
+
+    included do
+      extend Spree::DisplayMoney
+
+      has_many :role_users, foreign_key: "user_id", class_name: "Spree::RoleUser", dependent: :destroy
+      has_many :spree_roles, through: :role_users, source: :role, class_name: "Spree::Role"
+
+      has_many :user_stock_locations, foreign_key: "user_id", class_name: "Spree::UserStockLocation"
+      has_many :stock_locations, through: :user_stock_locations
+
+      has_many :spree_orders, foreign_key: "user_id", class_name: "Spree::Order"
+      has_many :orders, foreign_key: "user_id", class_name: "Spree::Order", dependent: :restrict_with_exception
+
+      has_many :store_credits, -> { includes(:credit_type) }, foreign_key: "user_id", class_name: "Spree::StoreCredit"
+      has_many :store_credit_events, through: :store_credits
+
+      money_methods :total_available_store_credit
+      deprecate display_total_available_store_credit: :display_available_store_credit_total, deprecator: Spree::Deprecation
+
+      has_many :credit_cards, class_name: "Spree::CreditCard", foreign_key: :user_id
+      has_many :wallet_payment_sources, foreign_key: 'user_id', class_name: 'Spree::WalletPaymentSource', inverse_of: :user
+
+      include Spree::RansackableAttributes unless included_modules.include?(Spree::RansackableAttributes)
+
+      self.whitelisted_ransackable_associations = %w[addresses spree_roles]
+      self.whitelisted_ransackable_attributes = %w[id email created_at]
+    end
+
+    def wallet
+      Spree::Wallet.new(self)
+    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
+
+    # @return [Spree::Order] the most-recently-created incomplete order
+    # since the customer's last complete order.
+    def last_incomplete_spree_order(store: nil, only_frontend_viewable: true)
+      self_orders = orders
+      self_orders = self_orders.where(frontend_viewable: true) if only_frontend_viewable
+      self_orders = self_orders.where(store: store) if store
+      self_orders = self_orders.where('updated_at > ?', Spree::Config.completable_order_updated_cutoff_days.days.ago) if Spree::Config.completable_order_updated_cutoff_days
+      self_orders = self_orders.where('created_at > ?', Spree::Config.completable_order_created_cutoff_days.days.ago) if Spree::Config.completable_order_created_cutoff_days
+      last_order = self_orders.order(:created_at).last
+      last_order unless last_order.try!(:completed?)
+    end
+
+    def total_available_store_credit
+      store_credits.reload.to_a.sum(&:amount_remaining)
+    end
+    deprecate total_available_store_credit: :available_store_credit_total, deprecator: Spree::Deprecation
+
+    def available_store_credit_total(currency:)
+      store_credits.reload.to_a.
+        select { |c| c.currency == currency }.
+        sum(&:amount_remaining)
+    end
+
+    def display_available_store_credit_total(currency:)
+      Spree::Money.new(
+        available_store_credit_total(currency: currency),
+        currency: currency,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spree
+  module UserPaymentSource
+    extend ActiveSupport::Concern
+
+    def default_credit_card
+      Spree::Deprecation.warn(
+        "user.default_credit_card is deprecated. Please use user.wallet.default_wallet_payment_source instead.",
+        caller
+      )
+      default = wallet.default_wallet_payment_source
+      if default && default.payment_source.is_a?(Spree::CreditCard)
+        default.payment_source
+      end
+    end
+
+    def payment_sources
+      Spree::Deprecation.warn(
+        "user.payment_sources is deprecated. Please use user.wallet.wallet_payment_sources instead.",
+        caller
+      )
+      credit_cards.with_payment_profile
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Spree
+  module UserReporting
+    extend DisplayMoney
+    money_methods :lifetime_value, :average_order_value
+
+    def lifetime_value
+      spree_orders.complete.pluck(:total).sum
+    end
+
+    def order_count
+      BigDecimal(spree_orders.complete.count)
+    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/spree/ability.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# 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
+
+    attr_reader :user
+
+    # 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)
+      abilities.add(ability)
+    end
+
+    def self.remove_ability(ability)
+      abilities.delete(ability)
+    end
+
+    def initialize(current_user)
+      @user = current_user || Spree.user_class.new
+
+      alias_actions
+      activate_permission_sets
+      register_extension_abilities
+    end
+
+    private
+
+    def alias_actions
+      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
+    end
+
+    # Before, this was the only way to extend this ability. Permission sets have been added since.
+    # It is recommended to use them instead for extension purposes if possible.
+    def register_extension_abilities
+      Ability.abilities.each do |clazz|
+        ability = clazz.send(:new, user)
+        merge(ability)
+      end
+    end
+
+    def activate_permission_sets
+      Spree::Config.roles.activate_permissions! self, user
+    end
+  end
+end