solidus_core 1.0.0.pre

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

@@ -0,0 +1,83 @@
+module Spree
+  module Core
+    module ControllerHelpers
+      module Auth
+        extend ActiveSupport::Concern
+
+        included do
+          before_filter :set_guest_token
+          helper_method :try_spree_current_user
+
+          rescue_from CanCan::AccessDenied do |exception|
+            redirect_unauthorized_access
+          end
+        end
+
+        # Needs to be overriden so that we use Spree's Ability rather than anyone else's.
+        def current_ability
+          @current_ability ||= Spree::Ability.new(try_spree_current_user)
+        end
+
+        def redirect_back_or_default(default)
+          redirect_to(session["spree_user_return_to"] || default)
+          session["spree_user_return_to"] = nil
+        end
+
+        def set_guest_token
+          unless cookies.signed[:guest_token].present?
+            cookies.permanent.signed[:guest_token] = SecureRandom.urlsafe_base64(nil, false)
+          end
+        end
+
+        def store_location
+          # disallow return to login, logout, signup pages
+          authentication_routes = [:spree_signup_path, :spree_login_path, :spree_logout_path]
+          disallowed_urls = []
+          authentication_routes.each do |route|
+            if respond_to?(route)
+              disallowed_urls << send(route)
+            end
+          end
+
+          disallowed_urls.map!{ |url| url[/\/\w+$/] }
+          unless disallowed_urls.include?(request.fullpath)
+            session['spree_user_return_to'] = request.fullpath.gsub('//', '/')
+          end
+        end
+
+        # proxy method to *possible* spree_current_user method
+        # Authentication extensions (such as spree_auth_devise) are meant to provide spree_current_user
+        def try_spree_current_user
+          # This one will be defined by apps looking to hook into Spree
+          # As per authentication_helpers.rb
+          if respond_to?(:spree_current_user)
+            spree_current_user
+          # This one will be defined by Devise
+          elsif respond_to?(:current_spree_user)
+            current_spree_user
+          else
+            nil
+          end
+        end
+
+        # Redirect as appropriate when an access request fails.  The default action is to redirect to the login screen.
+        # Override this method in your controllers if you want to have special behavior in case the user is not authorized
+        # to access the requested action.  For example, a popup window might simply close itself.
+        def redirect_unauthorized_access
+          if try_spree_current_user
+            flash[:error] = Spree.t(:authorization_failure)
+            redirect_to '/unauthorized'
+          else
+            store_location
+            if respond_to?(:spree_login_path)
+              redirect_to spree_login_path
+            else
+              redirect_to '/unauthorized'
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Spree
+  module Core
+    module ControllerHelpers
+      module Common
+        extend ActiveSupport::Concern
+        included do
+          helper_method :title
+          helper_method :title=
+          helper_method :accurate_title
+
+          layout :get_layout
+
+          before_filter :set_user_language
+
+          protected
+
+          # can be used in views as well as controllers.
+          # e.g. <% self.title = 'This is a custom title for this view' %>
+          attr_writer :title
+
+          def title
+            title_string = @title.present? ? @title : accurate_title
+            if title_string.present?
+              if Spree::Config[:always_put_site_name_in_title]
+                [title_string, default_title].join(' - ')
+              else
+                title_string
+              end
+            else
+              default_title
+            end
+          end
+
+          def default_title
+            current_store.name
+          end
+
+          # this is a hook for subclasses to provide title
+          def accurate_title
+            current_store.seo_title
+          end
+
+          def render_404(exception = nil)
+            respond_to do |type|
+              type.html { render :status => :not_found, :file    => "#{::Rails.root}/public/404", :formats => [:html], :layout => nil}
+              type.all  { render :status => :not_found, :nothing => true }
+            end
+          end
+
+          private
+
+          def set_user_language
+            locale = session[:locale]
+            locale ||= config_locale if respond_to?(:config_locale, true)
+            locale ||= Rails.application.config.i18n.default_locale
+            locale ||= I18n.default_locale unless I18n.available_locales.map(&:to_s).include?(locale)
+            I18n.locale = locale
+          end
+
+          # Returns which layout to render.
+          #
+          # You can set the layout you want to render inside your Spree configuration with the +:layout+ option.
+          #
+          # Default layout is: +app/views/spree/layouts/spree_application+
+          #
+          def get_layout
+            layout ||= Spree::Config[:layout]
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+module Spree
+  module Core
+    module ControllerHelpers
+      module Order
+        extend ActiveSupport::Concern
+
+        included do
+          before_filter :set_current_order
+
+          helper_method :current_currency
+          helper_method :current_order
+          helper_method :simple_current_order
+        end
+
+        # Used in the link_to_cart helper.
+        def simple_current_order
+
+          return @simple_current_order if @simple_current_order
+
+          @simple_current_order = find_order_by_token_or_user
+
+          if @simple_current_order
+            @simple_current_order.last_ip_address = ip_address
+            return @simple_current_order
+          else
+            @simple_current_order = Spree::Order.new
+          end
+        end
+
+        # The current incomplete order from the guest_token for use in cart and during checkout
+        def current_order(options = {})
+          options[:create_order_if_necessary] ||= false
+
+          return @current_order if @current_order
+
+          @current_order = find_order_by_token_or_user(options, true)
+
+          if options[:create_order_if_necessary] && (@current_order.nil? || @current_order.completed?)
+            @current_order = Spree::Order.new(current_order_params)
+            @current_order.user ||= try_spree_current_user
+            # See issue #3346 for reasons why this line is here
+            @current_order.created_by ||= try_spree_current_user
+            @current_order.save!
+          end
+
+          if @current_order
+            @current_order.last_ip_address = ip_address
+            return @current_order
+          end
+        end
+
+        def associate_user
+          @order ||= current_order
+          if try_spree_current_user && @order
+            @order.associate_user!(try_spree_current_user) if @order.user.blank? || @order.email.blank?
+          end
+        end
+
+        def set_current_order
+          if try_spree_current_user && current_order
+            try_spree_current_user.orders.incomplete.where('id != ?', current_order.id).each do |order|
+              current_order.merge!(order, try_spree_current_user)
+            end
+          end
+        end
+
+        def current_currency
+          Spree::Config[:currency]
+        end
+
+        def ip_address
+          request.remote_ip
+        end
+
+        private
+
+        def last_incomplete_order
+          @last_incomplete_order ||= try_spree_current_user.last_incomplete_spree_order(store: current_store)
+        end
+
+        def current_order_params
+          { currency: current_currency, guest_token: cookies.signed[:guest_token], store_id: current_store.id, user_id: try_spree_current_user.try(:id) }
+        end
+
+        def find_order_by_token_or_user(options={}, with_adjustments = false)
+          options[:lock] ||= false
+
+          # Find any incomplete orders for the guest_token
+          if with_adjustments
+            order = Spree::Order.incomplete.includes(:adjustments).lock(options[:lock]).find_by(current_order_params)
+          else
+            order = Spree::Order.incomplete.lock(options[:lock]).find_by(current_order_params)
+          end
+
+          # Find any incomplete orders for the current user
+          if order.nil? && try_spree_current_user
+            order = last_incomplete_order
+          end
+
+          order
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require 'spree/responder'
+
+module ActionController
+  class Base
+    def respond_with(*resources, &block)
+      if Spree::BaseController.spree_responders.keys.include?(self.class.to_s.to_sym)
+        # Checkout AS Array#extract_options! and original respond_with
+        # implementation for a better picture of this hack
+        if resources.last.is_a? Hash
+          resources.last.merge! action_name: action_name.to_sym
+        else
+          resources.push action_name: action_name.to_sym
+        end
+      end
+
+      super
+    end
+  end
+end
+
+module Spree
+  module Core
+    module ControllerHelpers
+      module RespondWith
+        extend ActiveSupport::Concern
+
+        included do
+          cattr_accessor :spree_responders
+          self.spree_responders = {}
+          self.responder = Spree::Responder
+        end
+
+        module ClassMethods
+          def clear_overrides!
+            self.spree_responders = {}
+          end
+
+          def respond_override(options={})
+            unless options.blank?
+              action_name = options.keys.first
+              action_value = options.values.first
+
+              if action_name.blank? || action_value.blank?
+                raise ArgumentError, "invalid values supplied #{options.inspect}"
+              end
+
+              format_name = action_value.keys.first
+              format_value = action_value.values.first
+
+              if format_name.blank? || format_value.blank?
+                raise ArgumentError, "invalid values supplied #{options.inspect}"
+              end
+
+              if format_value.is_a?(Proc)
+                options = {action_name.to_sym => {format_name.to_sym => {:success => format_value}}}
+              end
+
+              self.spree_responders.deep_merge!(self.name.to_sym => options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Spree
+  module Core
+    module ControllerHelpers
+      module Search
+        def build_searcher params
+          Spree::Config.searcher_class.new(params).tap do |searcher|
+            searcher.current_user = try_spree_current_user
+            searcher.current_currency = current_currency
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Spree
+  module Core
+    module ControllerHelpers
+      module Store
+        extend ActiveSupport::Concern
+
+        included do
+
+          def current_store
+            @current_store ||= Spree::Store.current(request.env['SERVER_NAME'])
+          end
+          helper_method :current_store
+
+        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("#{association}=", self.class.reflect_on_association(association).klass.new) 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("#{association}=", self.class.reflect_on_association(association).klass.new) if send(association).nil?
+    send(association).send("#{attr}=", val)
+  end
+  protected :delegator_for
+  protected :delegator_for_setter
+end
+
+ActiveRecord::Base.send :include, DelegateBelongsTo