solidus_core 1.0.0.pre

data/app/helpers/spree/store_helper.rb

@@ -0,0 +1,16 @@
+module Spree
+  # Methods added to this helper will be available to all templates in the
+  # frontend.
+  module StoreHelper
+    # @return [Boolean] true when it is appropriate to show the store menu
+    def store_menu?
+      %w{thank_you}.exclude? params[:action]
+    end
+
+    def cache_key_for_taxons
+      max_updated_at = @taxons.maximum(:updated_at).to_i
+      parts = [@taxon.try(:id), max_updated_at].compact.join("-")
+      "#{I18n.locale}/taxons/#{parts}"
+    end
+  end
+end

data/app/helpers/spree/taxons_helper.rb

@@ -0,0 +1,19 @@
+module Spree
+  module TaxonsHelper
+    # Retrieves the collection of products to display when "previewing" a taxon.  This is abstracted into a helper so
+    # that we can use configurations as well as make it easier for end users to override this determination.  One idea is
+    # to show the most popular products for a particular taxon (that is an exercise left to the developer.)
+    def taxon_preview(taxon, max=4)
+      products = taxon.active_products.select("DISTINCT (spree_products.id), spree_products.*, spree_products_taxons.position").limit(max)
+      if (products.size < max)
+        products_arel = Spree::Product.arel_table
+        taxon.descendants.each do |taxon|
+          to_get = max - products.length
+          products += taxon.active_products.select("DISTINCT (spree_products.id), spree_products.*, spree_products_taxons.position").where(products_arel[:id].not_in(products.map(&:id))).limit(to_get)
+          break if products.size >= max
+        end
+      end
+      products
+    end
+  end
+end

data/app/mailers/spree/base_mailer.rb

@@ -0,0 +1,23 @@
+module Spree
+  class BaseMailer < ActionMailer::Base
+
+    def from_address(store = nil)
+      if store
+        store.mail_from_address
+      else
+        ActiveSupport::Deprecation.warn "A Spree::Store should be provided to determine the from address.", caller
+        Spree::Config[:mails_from]
+      end
+    end
+
+    def money(amount, currency = Spree::Config[:currency])
+      Spree::Money.new(amount, currency: currency).to_s
+    end
+    helper_method :money
+
+    def mail(headers={}, &block)
+      super if Spree::Config[:send_core_emails]
+    end
+
+  end
+end

data/app/mailers/spree/carton_mailer.rb

@@ -0,0 +1,12 @@
+module Spree
+  class CartonMailer < BaseMailer
+    # Send an email to customers to notify that an individual carton has been
+    # shipped.
+    def shipped_email(carton_id, resend: false)
+      @carton = Spree::Carton.find(carton_id)
+      subject = (resend ? "[#{Spree.t(:resend).upcase}] " : '')
+      subject += "#{Spree::Store.current.name} #{Spree.t('shipment_mailer.shipped_email.subject')} ##{@carton.order_numbers.join(', ')}"
+      mail(to: @carton.order_emails, from: from_address, subject: subject)
+    end
+  end
+end

data/app/mailers/spree/order_mailer.rb

@@ -0,0 +1,35 @@
+module Spree
+  class OrderMailer < BaseMailer
+    def confirm_email(order, resend = false)
+      @order = find_order(order)
+      subject = build_subject(Spree.t('order_mailer.confirm_email.subject'), resend)
+
+      mail(to: @order.email, from: from_address(@order.store), subject: subject)
+    end
+
+    def cancel_email(order, resend = false)
+      @order = find_order(order)
+      subject = build_subject(Spree.t('order_mailer.cancel_email.subject'), resend)
+
+      mail(to: @order.email, from: from_address(@order.store), subject: subject)
+    end
+
+    def inventory_cancellation_email(order, inventory_units, resend = false)
+      @order, @inventory_units = find_order(order), inventory_units
+      subject = build_subject(Spree.t('order_mailer.inventory_cancellation.subject'), resend)
+
+      mail(to: @order.email, from: from_address(@order.store), subject: subject)
+    end
+
+    private
+
+    def find_order(order)
+      @order = order.respond_to?(:id) ? order : Spree::Order.find(order)
+    end
+
+    def build_subject(subject_text, resend)
+      subject = (resend ? "[#{Spree.t(:resend).upcase}] " : '')
+      subject += "#{Spree::Store.current.name} #{subject_text} ##{@order.number}"
+    end
+  end
+end

data/app/mailers/spree/reimbursement_mailer.rb

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

data/app/mailers/spree/test_mailer.rb

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

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

@@ -0,0 +1,24 @@
+module Spree
+  module AdjustmentSource
+    extend ActiveSupport::Concern
+
+    included do
+      def deals_with_adjustments_for_deleted_source
+        adjustment_scope = self.adjustments.includes(:order).references(:spree_orders)
+
+        # For incomplete orders, remove the adjustment completely.
+        adjustment_scope.where("spree_orders.completed_at IS NULL").destroy_all
+
+        # For complete orders, the source will be invalid.
+        # Therefore we nullify the source_id, leaving the adjustment in place.
+        # This would mean that the order's total is not altered at all.
+        adjustment_scope.where("spree_orders.completed_at IS NOT NULL").each do |adjustment|
+          adjustment.update_columns(
+            source_id: nil,
+            updated_at: Time.now,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+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
+      validates :calculator, presence: true
+
+      def self.calculators
+        spree_calculators.send model_name_without_spree_namespace
+      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 && !self.calculator.is_a?(klass)
+      end
+
+      private
+      def self.model_name_without_spree_namespace
+        self.to_s.tableize.gsub('/', '_').sub('spree_', '')
+      end
+
+      def self.spree_calculators
+        Rails.application.config.spree.calculators
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Spree
+  module DefaultPrice
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :default_price,
+        -> { where currency: Spree::Config[:currency] },
+        class_name: 'Spree::Price',
+        dependent: :destroy
+
+      delegate_belongs_to :default_price, :display_price, :display_amount, :price, :price=, :currency
+
+      after_save :save_default_price
+
+      def default_price
+        Spree::Price.unscoped { super }
+      end
+
+      def has_default_price?
+        !self.default_price.nil?
+      end
+
+      private
+
+      def default_price_changed?
+        default_price && (default_price.changed? || default_price.new_record?)
+      end
+
+      def save_default_price
+        default_price.save if default_price_changed?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+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,12 @@
+module Spree
+  module NamedType
+    extend ActiveSupport::Concern
+
+    included do
+      scope :active, -> { where(active: true) }
+      default_scope -> { order("LOWER(#{self.table_name}.name)") }
+
+      validates :name, presence: true, uniqueness: { case_sensitive: false }
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Spree
+  module UserAddress
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :bill_address, foreign_key: :bill_address_id, class_name: 'Spree::Address'
+      alias_attribute :billing_address, :bill_address
+
+      belongs_to :ship_address, foreign_key: :ship_address_id, class_name: 'Spree::Address'
+      alias_attribute :shipping_address, :ship_address
+
+      accepts_nested_attributes_for :ship_address, :bill_address
+
+      def persist_order_address(order)
+        b_address = self.bill_address || self.build_bill_address
+        b_address.attributes = order.bill_address.attributes.except('id', 'updated_at', 'created_at')
+        b_address.save
+        self.update_attributes(bill_address_id: b_address.id)
+
+        # May not be present if delivery step has been removed
+        if order.ship_address
+          s_address = self.ship_address || self.build_ship_address
+          s_address.attributes = order.ship_address.attributes.except('id', 'updated_at', 'created_at')
+          s_address.save
+          self.update_attributes(ship_address_id: s_address.id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Spree
+  module UserApiAuthentication
+    def generate_spree_api_key!
+      self.spree_api_key = SecureRandom.hex(24)
+      save!
+    end
+
+    def clear_spree_api_key!
+      self.spree_api_key = nil
+      save!
+    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
+      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,74 @@
+# 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
+
+
+      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 :create, ReturnAuthorization do |return_authorization|
+          return_authorization.order.user == user
+        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, StockItem, stock_location: { active: true }
+        can :display, StockLocation, active: true
+        can :display, Taxon
+        can :display, Taxonomy
+        can [:display, :view_out_of_stock], Variant
+        can :display, Zone
+      end
+
+      # Include any abilities registered by extensions, etc.
+      Ability.abilities.each do |clazz|
+        ability = clazz.send(:new, user)
+        @rules = rules + ability.send(:rules)
+      end
+    end
+  end
+end