goca-spree-core 3.1.14.rails.5.0

data/lib/spree/core/controller_helpers/store.rb

@@ -0,0 +1,51 @@
+module Spree
+  module Core
+    module ControllerHelpers
+      module Store
+        extend ActiveSupport::Concern
+
+        included do
+          helper_method :current_currency
+          helper_method :current_store
+          helper_method :current_price_options
+        end
+
+        def current_currency
+          Spree::Config[:currency]
+        end
+
+        def current_store
+          @current_store ||= Spree::Store.current(request.env['SERVER_NAME'])
+        end
+
+        # Return a Hash of things that influence the prices displayed in your shop.
+        #
+        # By default, the only thing that influences prices that is the current order's +tax_zone+
+        # (to facilitate differing prices depending on VAT rate for digital products in Europe, see
+        # https://github.com/spree/spree/pull/6295 and https://github.com/spree/spree/pull/6662).
+        #
+        # If your prices depend on something else, overwrite this method and add
+        # more key/value pairs to the Hash it returns.
+        #
+        # Be careful though to also patch the following parts of Spree accordingly:
+        #
+        # * `Spree::VatPriceCalculation#gross_amount`
+        # * `Spree::LineItem#update_price`
+        # * `Spree::Stock::Estimator#taxation_options_for`
+        # * Subclass the `DefaultTax` calculator
+        #
+        def current_price_options
+          {
+            tax_zone: current_tax_zone
+          }
+        end
+
+        private
+
+        def current_tax_zone
+          current_order.try(:tax_zone) || Spree::Zone.default_tax
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/controller_helpers/strong_parameters.rb

@@ -0,0 +1,42 @@
+module Spree
+  module Core
+    module ControllerHelpers
+      module StrongParameters
+        def permitted_attributes
+          Spree::PermittedAttributes
+        end
+
+        delegate *Spree::PermittedAttributes::ATTRIBUTES,
+                 to: :permitted_attributes,
+                 prefix: :permitted
+
+        def permitted_payment_attributes
+          permitted_attributes.payment_attributes + [
+            source_attributes: permitted_source_attributes
+          ]
+        end
+
+        def permitted_checkout_attributes
+          permitted_attributes.checkout_attributes + [
+            bill_address_attributes: permitted_address_attributes,
+            ship_address_attributes: permitted_address_attributes,
+            payments_attributes: permitted_payment_attributes,
+            shipments_attributes: permitted_shipment_attributes
+          ]
+        end
+
+        def permitted_order_attributes
+          permitted_checkout_attributes + [
+            line_items_attributes: permitted_line_item_attributes
+          ]
+        end
+
+        def permitted_product_attributes
+          permitted_attributes.product_attributes + [
+            product_properties_attributes: permitted_product_properties_attributes
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/delegate_belongs_to.rb

@@ -0,0 +1,95 @@
+##
+# Creates methods on object which delegate to an association proxy.
+# see delegate_belongs_to for two uses
+#
+# Todo - integrate with ActiveRecord::Dirty to make sure changes to delegate object are noticed
+# Should do
+# class User < Spree::Base; delegate_belongs_to :contact, :firstname; end
+# class Contact < Spree::Base; end
+# u = User.first
+# u.changed? # => false
+# u.firstname = 'Bobby'
+# u.changed? # => true
+#
+# Right now the second call to changed? would return false
+#
+# Todo - add has_one support. fairly straightforward addition
+##
+module DelegateBelongsTo
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+
+    @@default_rejected_delegate_columns = ['created_at','created_on','updated_at','updated_on','lock_version','type','id','position','parent_id','lft','rgt']
+    mattr_accessor :default_rejected_delegate_columns
+
+    ##
+    # Creates methods for accessing and setting attributes on an association.  Uses same
+    # default list of attributes as delegates_to_association.
+    # @todo Integrate this with ActiveRecord::Dirty, so if you set a property through one of these setters and then call save on this object, it will save the associated object automatically.
+    # delegate_belongs_to :contact
+    # delegate_belongs_to :contact, [:defaults]  ## same as above, and useless
+    # delegate_belongs_to :contact, [:defaults, :address, :fullname], :class_name => 'VCard'
+    ##
+    def delegate_belongs_to(association, *attrs)
+      opts = attrs.extract_options!
+      initialize_association :belongs_to, association, opts
+      attrs = get_association_column_names(association) if attrs.empty?
+      attrs.concat get_association_column_names(association) if attrs.delete :defaults
+      attrs.each do |attr|
+        class_def attr do |*args|
+          send(:delegator_for, association, attr, *args)
+        end
+
+        class_def "#{attr}=" do |val|
+          send(:delegator_for_setter, association, attr, val)
+        end
+      end
+    end
+
+    protected
+
+      def get_association_column_names(association, without_default_rejected_delegate_columns=true)
+        begin
+          association_klass = reflect_on_association(association).klass
+          methods = association_klass.column_names
+          methods.reject!{|x|default_rejected_delegate_columns.include?(x.to_s)} if without_default_rejected_delegate_columns
+          return methods
+        rescue
+          return []
+        end
+      end
+
+      ##
+      # initialize_association :belongs_to, :contact
+      def initialize_association(type, association, opts={})
+        raise 'Illegal or unimplemented association type.' unless [:belongs_to].include?(type.to_s.to_sym)
+        send type, association, opts if reflect_on_association(association).nil?
+      end
+
+    private
+      def class_def(name, method=nil, &blk)
+        class_eval { method.nil? ? define_method(name, &blk) : define_method(name, method) }
+      end
+  end
+
+  def delegator_for(association, attr, *args)
+    return if self.class.column_names.include?(attr.to_s)
+    send "build_#{association}" if send(association).nil?
+    if args.empty?
+      send(association).send(attr)
+    else
+      send(association).send(attr, *args)
+    end
+  end
+
+  def delegator_for_setter(association, attr, val)
+    return if self.class.column_names.include?(attr.to_s)
+    send "build_#{association}" if send(association).nil?
+    send(association).send("#{attr}=", val)
+  end
+  protected :delegator_for
+  protected :delegator_for_setter
+end
+
+ActiveRecord::Base.send :include, DelegateBelongsTo

data/lib/spree/core/engine.rb

@@ -0,0 +1,134 @@
+module Spree
+  module Core
+    class Engine < ::Rails::Engine
+      isolate_namespace Spree
+      engine_name 'spree'
+
+      rake_tasks do
+        load File.join(root, 'lib', 'tasks', 'exchanges.rake')
+      end
+
+      initializer 'spree.environment', before: :load_config_initializers do |app|
+        app.config.spree = Spree::Core::Environment.new
+        Spree::Config = app.config.spree.preferences # legacy access
+      end
+
+      initializer 'spree.register.calculators' do |app|
+        app.config.spree.calculators.shipping_methods = [
+          Spree::Calculator::Shipping::FlatPercentItemTotal,
+          Spree::Calculator::Shipping::FlatRate,
+          Spree::Calculator::Shipping::FlexiRate,
+          Spree::Calculator::Shipping::PerItem,
+          Spree::Calculator::Shipping::PriceSack
+        ]
+
+        app.config.spree.calculators.tax_rates = [
+          Spree::Calculator::DefaultTax
+        ]
+      end
+
+      initializer 'spree.register.stock_splitters' do |app|
+        app.config.spree.stock_splitters = [
+          Spree::Stock::Splitter::ShippingCategory,
+          Spree::Stock::Splitter::Backordered
+        ]
+      end
+
+      initializer 'spree.register.payment_methods', after: 'acts_as_list.insert_into_active_record' do |app|
+        app.config.spree.payment_methods = [
+          Spree::Gateway::Bogus,
+          Spree::Gateway::BogusSimple,
+          Spree::PaymentMethod::Check,
+          Spree::PaymentMethod::StoreCredit
+        ]
+      end
+
+      initializer 'spree.register.adjustable_adjusters' do |app|
+        app.config.spree.adjusters = [
+          Spree::Adjustable::Adjuster::Promotion,
+          Spree::Adjustable::Adjuster::Tax
+        ]
+      end
+
+      # We need to define promotions rules here so extensions and existing apps
+      # can add their custom classes on their initializer files
+      initializer 'spree.promo.environment' do |app|
+        app.config.spree.add_class('promotions')
+        app.config.spree.promotions = Spree::Promo::Environment.new
+        app.config.spree.promotions.rules = []
+      end
+
+      initializer 'spree.promo.register.promotion.calculators' do |app|
+        app.config.spree.calculators.add_class('promotion_actions_create_adjustments')
+        app.config.spree.calculators.promotion_actions_create_adjustments = [
+          Spree::Calculator::FlatPercentItemTotal,
+          Spree::Calculator::FlatRate,
+          Spree::Calculator::FlexiRate,
+          Spree::Calculator::TieredPercent,
+          Spree::Calculator::TieredFlatRate
+        ]
+
+        app.config.spree.calculators.add_class('promotion_actions_create_item_adjustments')
+        app.config.spree.calculators.promotion_actions_create_item_adjustments = [
+          Spree::Calculator::PercentOnLineItem,
+          Spree::Calculator::FlatRate,
+          Spree::Calculator::FlexiRate
+        ]
+      end
+
+      # Promotion rules need to be evaluated on after initialize otherwise
+      # Spree.user_class would be nil and users might experience errors related
+      # to malformed model associations (Spree.user_class is only defined on
+      # the app initializer)
+      config.after_initialize do
+        Rails.application.config.spree.promotions.rules.concat [
+          Spree::Promotion::Rules::ItemTotal,
+          Spree::Promotion::Rules::Product,
+          Spree::Promotion::Rules::User,
+          Spree::Promotion::Rules::FirstOrder,
+          Spree::Promotion::Rules::UserLoggedIn,
+          Spree::Promotion::Rules::OneUsePerUser,
+          Spree::Promotion::Rules::Taxon,
+          Spree::Promotion::Rules::OptionValue
+        ]
+      end
+
+      initializer 'spree.promo.register.promotions.actions' do |app|
+        app.config.spree.promotions.actions = [
+          Promotion::Actions::CreateAdjustment,
+          Promotion::Actions::CreateItemAdjustments,
+          Promotion::Actions::CreateLineItems,
+          Promotion::Actions::FreeShipping]
+      end
+
+      # filter sensitive information during logging
+      initializer 'spree.params.filter' do |app|
+        app.config.filter_parameters += [
+          :password,
+          :password_confirmation,
+          :number,
+          :verification_value]
+      end
+
+      initializer 'spree.core.checking_migrations' do
+        Migrations.new(config, engine_name).check
+      end
+
+      config.to_prepare do
+        # Ensure spree locale paths are present before decorators
+        I18n.load_path.unshift(*(Dir.glob(
+          File.join(
+            File.dirname(__FILE__), '../../../config/locales', '*.{rb,yml}'
+          )
+        ) - I18n.load_path))
+
+        # Load application's model / class decorators
+        Dir.glob(File.join(File.dirname(__FILE__), '../../../app/**/*_decorator*.rb')) do |c|
+          Rails.configuration.cache_classes ? require(c) : load(c)
+        end
+      end
+    end
+  end
+end
+
+require 'spree/core/routes'

data/lib/spree/core/environment/calculators.rb

@@ -0,0 +1,12 @@
+module Spree
+  module Core
+    class Environment
+      class Calculators
+        include EnvironmentExtension
+
+        attr_accessor :shipping_methods, :tax_rates
+      end
+    end
+  end
+end
+

data/lib/spree/core/environment.rb

@@ -0,0 +1,15 @@
+module Spree
+  module Core
+    class Environment
+      include EnvironmentExtension
+
+      attr_accessor :calculators, :payment_methods, :preferences,
+                    :adjusters, :stock_splitters
+
+      def initialize
+        @calculators = Calculators.new
+        @preferences = Spree::AppConfiguration.new
+      end
+    end
+  end
+end

data/lib/spree/core/environment_extension.rb

@@ -0,0 +1,25 @@
+module Spree
+  module Core
+    module EnvironmentExtension
+      extend ActiveSupport::Concern
+
+      def add_class(name)
+        self.instance_variable_set "@#{name}", Set.new
+
+        create_method( "#{name}=".to_sym ) { |val|
+          instance_variable_set( "@" + name, val)
+        }
+
+        create_method(name.to_sym) do
+          instance_variable_get( "@" + name )
+        end
+      end
+
+      private
+
+        def create_method(name, &block)
+          self.class.send(:define_method, name, &block)
+        end
+    end
+  end
+end

data/lib/spree/core/importer/order.rb

@@ -0,0 +1,284 @@
+module Spree
+  module Core
+    module Importer
+      class Order
+
+        def self.import(user, params)
+          begin
+            ensure_country_id_from_params params[:ship_address_attributes]
+            ensure_state_id_from_params params[:ship_address_attributes]
+            ensure_country_id_from_params params[:bill_address_attributes]
+            ensure_state_id_from_params params[:bill_address_attributes]
+
+            create_params = params.slice :currency
+            order = Spree::Order.create! create_params
+            order.associate_user!(user)
+
+            shipments_attrs = params.delete(:shipments_attributes)
+
+            create_line_items_from_params(params.delete(:line_items_attributes),order)
+            create_shipments_from_params(shipments_attrs, order)
+            create_adjustments_from_params(params.delete(:adjustments_attributes), order)
+            create_payments_from_params(params.delete(:payments_attributes), order)
+
+            if completed_at = params.delete(:completed_at)
+              order.completed_at = completed_at
+              order.state = 'complete'
+            end
+
+            params.delete(:user_id) unless user.try(:has_spree_role?, "admin") && params.key?(:user_id)
+
+            order.update_attributes!(params)
+
+            order.create_proposed_shipments unless shipments_attrs.present?
+
+            # Really ensure that the order totals & states are correct
+            order.updater.update
+            if shipments_attrs.present?
+              order.shipments.each_with_index do |shipment, index|
+                shipment.update_columns(cost: shipments_attrs[index][:cost].to_f) if shipments_attrs[index][:cost].present?
+              end
+            end
+            order.reload
+          rescue Exception => e
+            order.destroy if order && order.persisted?
+            raise e.message
+          end
+        end
+
+        def self.create_shipments_from_params(shipments_hash, order)
+          return [] unless shipments_hash
+
+          inventory_units = Spree::Stock::InventoryUnitBuilder.new(order).units
+
+          shipments_hash.each do |s|
+            begin
+              shipment = order.shipments.build
+              shipment.tracking       = s[:tracking]
+              shipment.stock_location = Spree::StockLocation.find_by_admin_name(s[:stock_location]) || Spree::StockLocation.find_by_name!(s[:stock_location])
+
+              shipment_units = s[:inventory_units] || []
+              shipment_units.each do |su|
+                ensure_variant_id_from_params(su)
+
+                inventory_unit = inventory_units.detect { |iu| iu.variant_id.to_i == su[:variant_id].to_i }
+
+                if inventory_unit.present?
+                  inventory_unit.shipment = shipment
+
+                  if s[:shipped_at].present?
+                    inventory_unit.pending = false
+                    inventory_unit.state = 'shipped'
+                  end
+
+                  inventory_unit.save!
+
+                  # Don't assign shipments to this inventory unit more than once
+                  inventory_units.delete(inventory_unit)
+                end
+              end
+
+              if s[:shipped_at].present?
+                shipment.shipped_at = s[:shipped_at]
+                shipment.state      = 'shipped'
+              end
+ 
+              shipment.save!
+
+              shipping_method = Spree::ShippingMethod.find_by_name(s[:shipping_method]) || Spree::ShippingMethod.find_by_admin_name!(s[:shipping_method])
+              rate = shipment.shipping_rates.create!(shipping_method: shipping_method, cost: s[:cost])
+
+              shipment.selected_shipping_rate_id = rate.id
+              shipment.update_amounts
+
+              adjustments = s.delete(:adjustments_attributes)
+              create_adjustments_from_params(adjustments, order, shipment)
+            rescue Exception => e
+              raise "Order import shipments: #{e.message} #{s}"
+            end
+          end
+        end
+
+        def self.create_line_items_from_params(line_items, order)
+          return {} unless line_items
+          iterator = case line_items
+          when Hash
+            ActiveSupport::Deprecation.warn(<<-EOS, caller)
+              Passing a hash is now deprecated and will be removed in Spree 4.0.
+              It is recommended that you pass it as an array instead.
+
+              New Syntax:
+
+              {
+                "order": {
+                  "line_items": [
+                    { "variant_id": 123, "quantity": 1 },
+                    { "variant_id": 456, "quantity": 1 }
+                  ]
+                }
+              }
+
+              Old Syntax:
+
+              {
+                "order": {
+                  "line_items": {
+                    "1": { "variant_id": 123, "quantity": 1 },
+                    "2": { "variant_id": 123, "quantity": 1 }
+                  }
+                }
+              }
+            EOS
+            :each_value
+          when Array
+            :each
+          end
+
+          line_items.send(iterator) do |line_item|
+            begin
+              adjustments = line_item.delete(:adjustments_attributes)
+              extra_params = line_item.except(:variant_id, :quantity, :sku)
+              line_item = ensure_variant_id_from_params(line_item)
+              variant = Spree::Variant.find(line_item[:variant_id])
+              line_item = order.contents.add(variant, line_item[:quantity])
+              # Raise any errors with saving to prevent import succeeding with line items
+              # failing silently.
+              if extra_params.present?
+                line_item.update_attributes!(extra_params)
+              else
+                line_item.save!
+              end
+              create_adjustments_from_params(adjustments, order, line_item)
+            rescue Exception => e
+              raise "Order import line items: #{e.message} #{line_item}"
+            end
+          end
+        end
+
+        def self.create_adjustments_from_params(adjustments, order, adjustable = nil)
+          return [] unless adjustments
+          adjustments.each do |a|
+            begin
+              adjustment = (adjustable || order).adjustments.build(
+                order: order,
+                amount: a[:amount].to_f,
+                label: a[:label],
+                source_type: source_type_from_adjustment(a)
+              )
+              adjustment.save!
+              adjustment.close!
+            rescue Exception => e
+              raise "Order import adjustments: #{e.message} #{a}"
+            end
+          end
+        end
+
+        def self.create_payments_from_params(payments_hash, order)
+          return [] unless payments_hash
+          payments_hash.each do |p|
+            begin
+              payment = order.payments.build order: order
+              payment.amount = p[:amount].to_f
+              # Order API should be using state as that's the normal payment field.
+              # spree_wombat serializes payment state as status so imported orders should fall back to status field.
+              payment.state = p[:state] || p[:status] || 'completed'
+              payment.created_at = p[:created_at] if p[:created_at]
+              payment.payment_method = Spree::PaymentMethod.find_by_name!(p[:payment_method])
+              payment.source = create_source_payment_from_params(p[:source], payment) if p[:source]
+              payment.save!
+            rescue Exception => e
+              raise "Order import payments: #{e.message} #{p}"
+            end
+          end
+        end
+
+        def self.create_source_payment_from_params(source_hash, payment)
+          begin
+            Spree::CreditCard.create(
+              month: source_hash[:month],
+              year: source_hash[:year],
+              cc_type: source_hash[:cc_type],
+              last_digits: source_hash[:last_digits],
+              name: source_hash[:name],
+              payment_method: payment.payment_method,
+              gateway_customer_profile_id: source_hash[:gateway_customer_profile_id],
+              gateway_payment_profile_id: source_hash[:gateway_payment_profile_id],
+              imported: true
+            )
+          rescue Exception => e
+            raise "Order import source payments: #{e.message} #{source_hash}"
+          end
+        end
+
+        def self.ensure_variant_id_from_params(hash)
+          begin
+            sku = hash.delete(:sku)
+            unless hash[:variant_id].present?
+              hash[:variant_id] = Spree::Variant.active.find_by_sku!(sku).id
+            end
+            hash
+          rescue ActiveRecord::RecordNotFound => e
+            raise "Ensure order import variant: Variant w/SKU #{sku} not found."
+          rescue Exception => e
+            raise "Ensure order import variant: #{e.message} #{hash}"
+          end
+        end
+
+        def self.ensure_country_id_from_params(address)
+          return if address.nil? or address[:country_id].present? or address[:country].nil?
+
+          begin
+            search = {}
+            if name = address[:country]['name']
+              search[:name] = name
+            elsif iso_name = address[:country]['iso_name']
+              search[:iso_name] = iso_name.upcase
+            elsif iso = address[:country]['iso']
+              search[:iso] = iso.upcase
+            elsif iso3 = address[:country]['iso3']
+              search[:iso3] = iso3.upcase
+            end
+
+            address.delete(:country)
+            address[:country_id] = Spree::Country.where(search).first!.id
+
+          rescue Exception => e
+            raise "Ensure order import address country: #{e.message} #{search}"
+          end
+        end
+
+        def self.ensure_state_id_from_params(address)
+          return if address.nil? or address[:state_id].present? or address[:state].nil?
+
+          begin
+            search = {}
+            if name = address[:state]['name']
+              search[:name] = name
+            elsif abbr = address[:state]['abbr']
+              search[:abbr] = abbr.upcase
+            end
+
+            address.delete(:state)
+            search[:country_id] = address[:country_id]
+
+            if state = Spree::State.where(search).first
+              address[:state_id] = state.id
+            else
+              address[:state_name] = search[:name] || search[:abbr]
+            end
+          rescue Exception => e
+            raise "Ensure order import address state: #{e.message} #{search}"
+          end
+        end
+
+        def self.source_type_from_adjustment(adjustment)
+          if adjustment[:tax]
+            'Spree::TaxRate'
+          elsif adjustment[:promotion]
+            'Spree::PromotionAction'
+          end
+        end
+      end
+    end
+  end
+end