spree_core 4.5.3 → 4.6.0

data/app/models/spree/taxon.rb

@@ -3,6 +3,8 @@ require 'stringex'
 
 module Spree
   class Taxon < Spree::Base
+    include TranslatableResource
+    include TranslatableResourceSlug
     include Metadata
     if defined?(Spree::Webhooks)
       include Spree::Webhooks::HasWebhooks
@@ -27,7 +29,7 @@ module Spree
     has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', dependent: :destroy
     has_many :promotion_rules, through: :promotion_rule_taxons, class_name: 'Spree::PromotionRule'
 
-    validates :name, presence: true, uniqueness: { scope: [:parent_id, :taxonomy_id], allow_blank: true, case_sensitive: false }
+    validates :name, presence: true, uniqueness: { scope: [:parent_id, :taxonomy_id], case_sensitive: false }
     validates :taxonomy, presence: true
     validates :permalink, uniqueness: { case_sensitive: false, scope: [:parent_id, :taxonomy_id] }
     validates :hide_from_nav, inclusion: { in: [true, false] }
@@ -54,6 +56,24 @@ module Spree
 
     scope :for_stores, ->(stores) { joins(:taxonomy).where(spree_taxonomies: { store_id: stores.ids }) }
 
+    TRANSLATABLE_FIELDS = %i[name description permalink].freeze
+    translates(*TRANSLATABLE_FIELDS)
+
+    self::Translation.class_eval do
+      alias_attribute :slug, :permalink
+
+      before_create :set_permalink
+
+      def set_permalink
+        parent = translated_model.parent
+        if parent.present?
+          self.permalink = [parent.permalink, (permalink.blank? ? name.to_url : permalink.split('/').last)].join('/')
+        else
+          self.permalink = name.to_url if permalink.blank?
+        end
+      end
+    end
+
     # indicate which filters should be used for a taxon
     # this method should be customized to your own site
     def applicable_filters
@@ -73,11 +93,7 @@ module Spree
 
     # Creates permalink base for friendly_id
     def set_permalink
-      if parent.present?
-        self.permalink = [parent.permalink, (permalink.blank? ? name.to_url : permalink.split('/').last)].join('/')
-      else
-        self.permalink = name.to_url if permalink.blank?
-      end
+      translations.each(&:set_permalink)
     end
 
     def active_products

data/app/models/spree/taxonomy.rb

@@ -1,10 +1,14 @@
 module Spree
   class Taxonomy < Spree::Base
+    include TranslatableResource
     include Metadata
     if defined?(Spree::Webhooks)
       include Spree::Webhooks::HasWebhooks
     end
 
+    TRANSLATABLE_FIELDS = %i[name].freeze
+    translates(*TRANSLATABLE_FIELDS)
+
     acts_as_list
 
     validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true, scope: :store_id }

data/app/models/spree/variant.rb

@@ -122,16 +122,13 @@ module Spree
     self.whitelisted_ransackable_scopes = %i(product_name_or_sku_cont search_by_product_name_or_sku)
 
     def self.product_name_or_sku_cont(query)
-      joins(:product).where("LOWER(#{Product.table_name}.name) LIKE LOWER(:query) OR LOWER(sku) LIKE LOWER(:query)", query: "%#{query}%")
+      joins(:product).join_translation_table(Product).
+        where("LOWER(#{Product.translation_table_alias}.name) LIKE LOWER(:query)
+               OR LOWER(sku) LIKE LOWER(:query)", query: "%#{query}%")
     end
 
     def self.search_by_product_name_or_sku(query)
-      if defined?(SpreeGlobalize)
-        joins(product: :translations).where("LOWER(#{Product::Translation.table_name}.name) LIKE LOWER(:query) OR LOWER(sku) LIKE LOWER(:query)",
-                                            query: "%#{query}%")
-      else
-        product_name_or_sku_cont(query)
-      end
+      product_name_or_sku_cont(query)
     end
 
     def available?

data/app/services/spree/data_feeds/google/optional_attributes.rb

@@ -0,0 +1,23 @@
+module Spree
+  module DataFeeds
+    module Google
+      class OptionalAttributes
+        prepend Spree::ServiceModule::Base
+
+        def call(input)
+          information = {}
+
+          input[:product].property_ids.each do |key|
+            name = Spree::Property.find(key)&.name
+            value = input[:product].property(name)
+            unless value.nil?
+              information[name] = value
+            end
+          end
+
+          success(information: information)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/data_feeds/google/optional_sub_attributes.rb

@@ -0,0 +1,21 @@
+module Spree
+  module DataFeeds
+    module Google
+      class OptionalSubAttributes
+        prepend Spree::ServiceModule::Base
+
+        def call(input)
+          information = {}
+
+          # This is a place where you can put attributes that have sub-attributes, example for shipping:
+          #
+          # information['shipping'] = {}
+          # information['shipping']['price'] = calculate_shipping(input[:product])
+          # information['shipping']['country'] = input[:store].default_country
+
+          success(information: information)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/data_feeds/google/products_list.rb

@@ -0,0 +1,14 @@
+module Spree
+  module DataFeeds
+    module Google
+      class ProductsList
+        prepend Spree::ServiceModule::Base
+
+        def call(store)
+          products = store.products.active
+          success(products: products)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/data_feeds/google/required_attributes.rb

@@ -0,0 +1,67 @@
+module Spree
+  module DataFeeds
+    module Google
+      class RequiredAttributes
+        prepend Spree::ServiceModule::Base
+
+        def call(input)
+          information = {}
+
+          return failure(nil, error: 'No image link') if get_image_link(input[:variant], input[:product]).nil?
+
+          information['id'] = input[:variant].id
+          information['title'] = format_title(input[:product], input[:variant])
+          information['description'] = get_description(input[:product], input[:variant])
+          information['link'] = "#{input[:store].url}/#{input[:product].slug}"
+          information['image_link'] = get_image_link(input[:variant], input[:product])
+          information['price'] = format_price(input[:variant])
+          information['availability'] = get_availability(input[:product])
+          information['availability_date'] = input[:product].available_on&.xmlschema unless input[:product].available_on.nil?
+
+          success(information: information)
+        end
+
+        private
+
+        def format_title(product, variant)
+          # Title of a variant is created by joining title of a product and variant's option_values, as they are
+          # what differentiates it from other variants.
+          title = product.name
+          variant.option_values.find_each do |option_value|
+            title << " - #{option_value.name}"
+          end
+          title
+        end
+
+        def get_description(product, variant)
+          return product.description unless product.description.nil?
+
+          format_title(product, variant)
+        end
+
+        def get_image_link(variant, product)
+          # try getting image from variant
+          img = variant.images.first&.plp_url
+
+          # if no image specified for variant try getting product image
+          if img.nil?
+            img = product.images.first&.plp_url
+          end
+
+          img
+        end
+
+        def format_price(variant)
+          "#{variant.price} #{variant.cost_currency}"
+        end
+
+        def get_availability(product)
+          return 'in stock' if product.available? && product.available_on&.past?
+          return 'backorder' if product.backorderable? && product.backordered? && product.available_on&.future?
+
+          'out of stock'
+        end
+      end
+    end
+  end
+end

data/app/services/spree/data_feeds/google/rss.rb

@@ -0,0 +1,107 @@
+require 'nokogiri'
+
+module Spree
+  module DataFeeds
+    module Google
+      class Rss
+        prepend Spree::ServiceModule::Base
+
+        def call(settings)
+          @settings = settings
+
+          return failure(store, error: "Store with id: #{settings.store_id} does not exist.") if store.nil?
+
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.rss('xmlns:g' => 'http://base.google.com/ns/1.0', 'version' => '2.0') do
+              xml.channel do
+                add_store_information_to_xml(xml)
+                result = products_list.call(store)
+                if result.success?
+                  result.value[:products].find_each do |product|
+                    product.variants.active.find_each do |variant|
+                      add_variant_information_to_xml(xml, product, variant)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          success(file: builder.to_xml)
+        end
+
+        private
+
+        def store
+          return @store if defined? @store
+
+          @store ||= Spree::Store.find_by(id: @settings.store_id)
+        end
+
+        def add_store_information_to_xml(xml)
+          xml.title store.name
+          xml.link store.url
+          xml.description store.meta_description
+        end
+
+        def add_variant_information_to_xml(xml, product, variant)
+          input = { product: product, variant: variant, settings: @settings, store: store }
+          result = required_attributes.call(input)
+
+          if result.success
+            xml.item do
+              result.value[:information]&.each do |key, value|
+                xml['g'].send(key, value)
+              end
+
+              add_optional_information(xml, product, variant)
+              add_optional_sub_attributes(xml, product, variant)
+            end
+          end
+        end
+
+        def add_optional_information(xml, product, variant)
+          input = { product: product, variant: variant, settings: @settings, store: store }
+          result = optional_attributes.call(input)
+          if result.success?
+            information = result.value[:information]
+            information.each do |key, value|
+              xml['g'].send(key, value)
+            end
+          end
+        end
+
+        def add_optional_sub_attributes(xml, product, variant)
+          input = { product: product, variant: variant, settings: @settings, store: store }
+          result = optional_sub_attributes.call(input)
+          if result.success?
+            information = result.value[:information]
+            information.each do |key, value|
+              xml['g'].send(key) do
+                value.each do |subkey, subvalue|
+                  xml['g'].send(subkey, subvalue)
+                end
+              end
+            end
+          end
+        end
+
+        def optional_attributes
+          Spree::Dependencies.data_feeds_google_optional_attributes_service.constantize.new
+        end
+
+        def required_attributes
+          Spree::Dependencies.data_feeds_google_required_attributes_service.constantize.new
+        end
+
+        def optional_sub_attributes
+          Spree::Dependencies.data_feeds_google_optional_sub_attributes_service.constantize.new
+        end
+
+        def products_list
+          Spree::Dependencies.data_feeds_google_products_list.constantize.new
+        end
+      end
+    end
+  end
+end

data/app/sorters/spree/products/sort.rb

@@ -11,6 +11,8 @@ module Spree
         products = by_price(products)
         products = by_sku(products)
 
+        products = select_translatable_fields(products)
+
         products.distinct
       end
 
@@ -46,6 +48,27 @@ module Spree
       def sort_by?(field)
         sort.detect { |s| s[0] == field }
       end
+
+      # Add translatable fields to SELECT statement to avoid InvalidColumnReference error (workaround for Mobility issue #596)
+      def select_translatable_fields(scope)
+        translatable_fields = translatable_sortable_fields
+        return scope if translatable_fields.empty?
+
+        # if sorting by 'sku' or 'price', spree_products.* is already included in SELECT statement
+        if sort_by?('sku') || sort_by?('price')
+          scope.i18n.select(*translatable_fields)
+        else
+          scope.i18n.select("#{Product.table_name}.*").select(*translatable_fields)
+        end
+      end
+
+      def translatable_sortable_fields
+        fields = []
+        Product.translatable_fields.each do |field|
+          fields << field if sort_by?(field.to_s)
+        end
+        fields
+      end
     end
   end
 end