solidus_core_devise_token_auth 2.8.0.alpha.0

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    module Importer
+      class Order
+        def self.import(user, params)
+          params = params.to_h
+          ActiveRecord::Base.transaction do
+            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.store ||= Spree::Store.default
+            order.associate_user!(user)
+            order.save!
+
+            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)
+
+            params.delete(:user_id) unless user.try(:has_spree_role?, "admin") && params.key?(:user_id)
+
+            completed_at = params.delete(:completed_at)
+
+            order.update_attributes!(params)
+
+            order.create_proposed_shipments unless shipments_attrs.present?
+
+            if completed_at
+              order.completed_at = completed_at
+              order.state = 'complete'
+              order.save!
+            end
+
+            # 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
+          end
+        end
+
+        def self.create_shipments_from_params(shipments_hash, order)
+          return [] unless shipments_hash
+
+          shipments_hash.each do |s|
+            shipment = Shipment.new
+            shipment.tracking       = s[:tracking]
+            shipment.stock_location = Spree::StockLocation.find_by(admin_name: s[:stock_location]) || Spree::StockLocation.find_by!(name: s[:stock_location])
+
+            inventory_units = s[:inventory_units] || []
+            inventory_units.each do |iu|
+              ensure_variant_id_from_params(iu)
+
+              unless line_item = order.line_items.find_by(variant_id: iu[:variant_id])
+                line_item = order.contents.add(Spree::Variant.find(iu[:variant_id]), 1)
+              end
+
+              # Spree expects a Inventory Unit to always reference a line
+              # item and variant otherwise users might get exceptions when
+              # trying to view these units. Note the Importer might not be
+              # able to find the line item if line_item.variant_id |= iu.variant_id
+              shipment.inventory_units.new(
+                variant_id: iu[:variant_id],
+                line_item: line_item
+              )
+            end
+
+            # Mark shipped if it should be.
+            if s[:shipped_at].present?
+              shipment.shipped_at = s[:shipped_at]
+              shipment.state      = 'shipped'
+              shipment.inventory_units.each do |unit|
+                unit.state = 'shipped'
+              end
+            end
+
+            order.shipments << shipment
+            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
+          end
+        end
+
+        def self.create_line_items_from_params(line_items_hash, order)
+          return {} unless line_items_hash
+          line_items_hash.each_key do |k|
+            extra_params = line_items_hash[k].except(:variant_id, :quantity, :sku)
+            line_item = ensure_variant_id_from_params(line_items_hash[k])
+            line_item = order.contents.add(Spree::Variant.find(line_item[:variant_id]), 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
+          end
+        end
+
+        def self.create_adjustments_from_params(adjustments, order)
+          return [] unless adjustments
+          adjustments.each do |a|
+            adjustment = order.adjustments.build(
+              order:  order,
+              amount: a[:amount].to_d,
+              label:  a[:label]
+            )
+            adjustment.save!
+            adjustment.finalize!
+          end
+        end
+
+        def self.create_payments_from_params(payments_hash, order)
+          return [] unless payments_hash
+          payments_hash.each do |p|
+            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.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!
+          end
+        end
+
+        def self.create_source_payment_from_params(source_hash, payment)
+          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
+          )
+        end
+
+        def self.ensure_variant_id_from_params(hash)
+          sku = hash.delete(:sku)
+          unless hash[:variant_id].present?
+            hash[:variant_id] = Spree::Variant.with_prices.find_by!(sku: sku).id
+          end
+          hash
+        end
+
+        def self.ensure_country_id_from_params(address)
+          return if address.nil? || address[:country_id].present? || address[:country].nil?
+
+          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
+        end
+
+        def self.ensure_state_id_from_params(address)
+          return if address.nil? || address[:state_id].present? || address[:state].nil?
+
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    module Importer
+      class Product
+        attr_reader :product, :product_attrs, :variants_attrs, :options_attrs
+
+        def initialize(product, product_params, options = {})
+          @product = product || Spree::Product.new(product_params)
+
+          @product_attrs = product_params.to_h
+          @variants_attrs = (options[:variants_attrs] || []).map(&:to_h)
+          @options_attrs = options[:options_attrs] || []
+        end
+
+        def create
+          if product.save
+            variants_attrs.each do |variant_attribute|
+              # make sure the product is assigned before the options=
+              product.variants.create({ product: product }.merge(variant_attribute))
+            end
+
+            set_up_options
+          end
+
+          product
+        end
+
+        def update
+          if product.update_attributes(product_attrs)
+            variants_attrs.each do |variant_attribute|
+              # update the variant if the id is present in the payload
+              if variant_attribute['id'].present?
+                product.variants.find(variant_attribute['id'].to_i).update_attributes(variant_attribute)
+              else
+                # make sure the product is assigned before the options=
+                product.variants.create({ product: product }.merge(variant_attribute))
+              end
+            end
+
+            set_up_options
+          end
+
+          product
+        end
+
+        private
+
+        def set_up_options
+          options_attrs.each do |name|
+            option_type = Spree::OptionType.where(name: name).first_or_initialize do |ot|
+              ot.presentation = name
+              ot.save!
+            end
+
+            unless product.option_types.include?(option_type)
+              product.option_types << option_type
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/importer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    module Importer
+    end
+  end
+end
+
+require 'spree/core/importer/order'
+require 'spree/core/importer/product'

data/lib/spree/core/permalinks.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    module Permalinks
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :permalink_options
+      end
+
+      module ClassMethods
+        def make_permalink(options = {})
+          options[:field] ||= :permalink
+          self.permalink_options = options
+
+          before_validation(on: :create) { save_permalink }
+        end
+
+        def find_by_param(value, *args)
+          send("find_by_#{permalink_field}", value, *args)
+        end
+
+        def find_by_param!(value, *args)
+          send("find_by_#{permalink_field}!", value, *args)
+        end
+
+        def permalink_field
+          permalink_options[:field]
+        end
+
+        def permalink_prefix
+          permalink_options[:prefix] || ""
+        end
+
+        def permalink_length
+          permalink_options[:length] || 9
+        end
+
+        def permalink_order
+          order = permalink_options[:order]
+          "#{order} ASC," if order
+        end
+      end
+
+      def generate_permalink
+        "#{self.class.permalink_prefix}#{Array.new(self.class.permalink_length){ rand(9) }.join}"
+      end
+
+      def save_permalink(permalink_value = to_param)
+        permalink_value ||= generate_permalink
+        permalink_field = self.class.permalink_field
+
+        loop do
+          other = self.class.where(permalink_field => permalink_value)
+          break unless other.exists?
+
+          # Try again with a new value
+          permalink_value = generate_permalink
+        end
+        write_attribute(permalink_field, permalink_value)
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Spree::Core::Permalinks

data/lib/spree/core/product_duplicator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Spree
+  class ProductDuplicator
+    attr_accessor :product
+
+    @@clone_images_default = true
+    mattr_accessor :clone_images_default
+
+    def initialize(product, include_images = @@clone_images_default)
+      @product = product
+      @include_images = include_images
+    end
+
+    def duplicate
+      new_product = duplicate_product
+
+      # don't dup the actual variants, just the characterising types
+      new_product.option_types = product.option_types if product.has_variants?
+
+      # allow site to do some customization
+      new_product.send(:duplicate_extra, product) if new_product.respond_to?(:duplicate_extra)
+      new_product.save!
+      new_product
+    end
+
+    protected
+
+    def duplicate_product
+      product.dup.tap do |new_product|
+        new_product.name = "COPY OF #{product.name}"
+        new_product.taxons = product.taxons
+        new_product.created_at = nil
+        new_product.deleted_at = nil
+        new_product.updated_at = nil
+        new_product.product_properties = reset_properties
+        new_product.master = duplicate_master
+        new_product.variants = product.variants.map { |variant| duplicate_variant variant }
+      end
+    end
+
+    def duplicate_master
+      master = product.master
+      master.dup.tap do |new_master|
+        new_master.sku = "COPY OF #{master.sku}"
+        new_master.deleted_at = nil
+        new_master.images = master.images.map { |image| duplicate_image image } if @include_images
+        new_master.price = master.price
+      end
+    end
+
+    def duplicate_variant(variant)
+      new_variant = variant.dup
+      new_variant.sku = "COPY OF #{new_variant.sku}"
+      new_variant.deleted_at = nil
+      new_variant.option_values = variant.option_values.map { |option_value| option_value }
+      new_variant
+    end
+
+    def duplicate_image(image)
+      new_image = image.dup
+      new_image.assign_attributes(attachment: image.attachment.clone)
+      new_image
+    end
+
+    def reset_properties
+      product.product_properties.map do |prop|
+        prop.dup.tap do |new_prop|
+          new_prop.created_at = nil
+          new_prop.updated_at = nil
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/product_filters.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    # THIS FILE SHOULD BE OVER-RIDDEN IN YOUR SITE EXTENSION!
+    #   the exact code probably won't be useful, though you're welcome to modify and reuse
+    #   the current contents are mainly for testing and documentation
+
+    # To override this file...
+    #   1) Make a copy of it in your sites local /lib/spree folder
+    #   2) Add it to the config load path, or require it in an initializer, e.g...
+    #
+    #      # config/initializers/spree.rb
+    #      require 'spree/product_filters'
+    #
+
+    # set up some basic filters for use with products
+    #
+    # Each filter has two parts
+    #  * a parametrized named scope which expects a list of labels
+    #  * an object which describes/defines the filter
+    #
+    # The filter description has three components
+    #  * a name, for displaying on pages
+    #  * a named scope which will 'execute' the filter
+    #  * a mapping of presentation labels to the relevant condition (in the context of the named scope)
+    #  * an optional list of labels and values (for use with object selection - see taxons examples below)
+    #
+    # The named scopes here have a suffix '_any', following Ransack's convention for a
+    # scope which returns results which match any of the inputs. This is purely a convention,
+    # but might be a useful reminder.
+    #
+    # When creating a form, the name of the checkbox group for a filter F should be
+    # the name of F's scope with [] appended, eg "price_range_any[]", and for
+    # each label you should have a checkbox with the label as its value. On submission,
+    # Rails will send the action a hash containing (among other things) an array named
+    # after the scope whose values are the active labels.
+    #
+    # Ransack will then convert this array to a call to the named scope with the array
+    # contents, and the named scope will build a query with the disjunction of the conditions
+    # relating to the labels, all relative to the scope's context.
+    #
+    # The details of how/when filters are used is a detail for specific models (eg products
+    # or taxons), eg see the taxon model/controller.
+
+    # See specific filters below for concrete examples.
+    module ProductFilters
+      # Example: filtering by price
+      #   The named scope just maps incoming labels onto their conditions, and builds the conjunction
+      #   'price' is in the base scope's context (ie, "select foo from products where ...") so
+      #     we can access the field right away
+      #   The filter identifies which scope to use, then sets the conditions for each price range
+      #
+      # If user checks off three different price ranges then the argument passed to
+      # below scope would be something like ["$10 - $15", "$15 - $18", "$18 - $20"]
+      #
+      Spree::Product.add_search_scope :price_range_any do |*opts|
+        conds = opts.map { |o| Spree::Core::ProductFilters.price_filter[:conds][o] }.reject(&:nil?)
+        scope = conds.shift
+        conds.each do |new_scope|
+          scope = scope.or(new_scope)
+        end
+        Spree::Product.joins(master: :default_price).where(scope)
+      end
+
+      def self.format_price(amount)
+        Spree::Money.new(amount)
+      end
+
+      def self.price_filter
+        v = Spree::Price.arel_table
+        conds = [[I18n.t('spree.under_price', price: format_price(10)), v[:amount].lteq(10)],
+                 ["#{format_price(10)} - #{format_price(15)}", v[:amount].in(10..15)],
+                 ["#{format_price(15)} - #{format_price(18)}", v[:amount].in(15..18)],
+                 ["#{format_price(18)} - #{format_price(20)}", v[:amount].in(18..20)],
+                 [I18n.t('spree.or_over_price', price: format_price(20)), v[:amount].gteq(20)]]
+        {
+          name:   I18n.t('spree.price_range'),
+          scope:  :price_range_any,
+          conds:  Hash[*conds.flatten],
+          labels: conds.map { |k, _v| [k, k] }
+        }
+      end
+
+      # Example: filtering by possible brands
+      #
+      # First, we define the scope. Two interesting points here: (a) we run our conditions
+      #   in the scope where the info for the 'brand' property has been loaded; and (b)
+      #   because we may want to filter by other properties too, we give this part of the
+      #   query a unique name (which must be used in the associated conditions too).
+      #
+      # Secondly, the filter. Instead of a static list of values, we pull out all existing
+      #   brands from the db, and then build conditions which test for string equality on
+      #   the (uniquely named) field "p_brand.value". There's also a test for brand info
+      #   being blank: note that this relies on with_property doing a left outer join
+      #   rather than an inner join.
+      Spree::Product.add_search_scope :brand_any do |*opts|
+        conds = opts.map { |o| ProductFilters.brand_filter[:conds][o] }.reject(&:nil?)
+        scope = conds.shift
+        conds.each do |new_scope|
+          scope = scope.or(new_scope)
+        end
+        Spree::Product.with_property('brand').where(scope)
+      end
+
+      def self.brand_filter
+        brand_property = Spree::Property.find_by(name: 'brand')
+        brands = brand_property ? Spree::ProductProperty.where(property_id: brand_property.id).pluck(:value).uniq.map(&:to_s) : []
+        pp = Spree::ProductProperty.arel_table
+        conds = Hash[*brands.map { |b| [b, pp[:value].eq(b)] }.flatten]
+        {
+          name:   'Brands',
+          scope:  :brand_any,
+          conds:  conds,
+          labels: brands.sort.map { |k| [k, k] }
+        }
+      end
+
+      # Example: a parameterized filter
+      #   The filter above may show brands which aren't applicable to the current taxon,
+      #   so this one only shows the brands that are relevant to a particular taxon and
+      #   its descendants.
+      #
+      #   We don't have to give a new scope since the conditions here are a subset of the
+      #   more general filter, so decoding will still work - as long as the filters on a
+      #   page all have unique names (ie, you can't use the two brand filters together
+      #   if they use the same scope). To be safe, the code uses a copy of the scope.
+      #
+      #   HOWEVER: what happens if we want a more precise scope?  we can't pass
+      #   parametrized scope names to Ransack, only atomic names, so couldn't ask
+      #   for taxon T's customized filter to be used. BUT: we can arrange for the form
+      #   to pass back a hash instead of an array, where the key acts as the (taxon)
+      #   parameter and value is its label array, and then get a modified named scope
+      #   to get its conditions from a particular filter.
+      #
+      #   The brand-finding code can be simplified if a few more named scopes were added to
+      #   the product properties model.
+      Spree::Product.add_search_scope :selective_brand_any do |*opts|
+        Spree::Product.brand_any(*opts)
+      end
+
+      def self.selective_brand_filter(taxon = nil)
+        taxon ||= Spree::Taxonomy.first.root
+        brand_property = Spree::Property.find_by(name: 'brand')
+        scope = Spree::ProductProperty.where(property: brand_property).
+          joins(product: :taxons).
+          where("#{Spree::Taxon.table_name}.id" => [taxon] + taxon.descendants)
+        brands = scope.pluck(:value).uniq
+        {
+          name:   'Applicable Brands',
+          scope:  :selective_brand_any,
+          labels: brands.sort.map { |k| [k, k] }
+        }
+      end
+
+      # Provide filtering on the immediate children of a taxon
+      #
+      # This doesn't fit the pattern of the examples above, so there's a few changes.
+      # Firstly, it uses an existing scope which was not built for filtering - and so
+      # has no need of a conditions mapping, and secondly, it has a mapping of name
+      # to the argument type expected by the other scope.
+      #
+      # This technique is useful for filtering on objects (by passing ids) or with a
+      # scope that can be used directly (eg. testing only ever on a single property).
+      #
+      # This scope selects products in any of the active taxons or their children.
+      #
+      def self.taxons_below(taxon)
+        Spree::Deprecation.warn "taxons_below is deprecated in solidus_core. Please add it to your own application to continue using it."
+        return Spree::Core::ProductFilters.all_taxons if taxon.nil?
+        {
+          name:   'Taxons under ' + taxon.name,
+          scope:  :taxons_id_in_tree_any,
+          labels: taxon.children.sort_by(&:position).map { |t| [t.name, t.id] },
+          conds:  nil
+        }
+      end
+
+      # Filtering by the list of all taxons
+      #
+      # Similar idea as above, but we don't want the descendants' products, hence
+      # it uses one of the auto-generated scopes from Ransack.
+      #
+      # idea: expand the format to allow nesting of labels?
+      def self.all_taxons
+        Spree::Deprecation.warn "all_taxons is deprecated in solidus_core. Please add it to your own application to continue using it."
+        taxons = Spree::Taxonomy.all.map { |t| [t.root] + t.root.descendants }.flatten
+        {
+          name:   'All taxons',
+          scope:  :taxons_id_equals_any,
+          labels: taxons.sort_by(&:name).map { |t| [t.name, t.id] },
+          conds:  nil # not needed
+        }
+      end
+    end
+  end
+end