spree_legacy_product_properties 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 52e57ea0de8690904e22e45a92e2fdc608723cc4583f47d3e5f2bdb004e9d139
+  data.tar.gz: 6cb6cb7f5d729ced258a185ca106fa0b878c1e1c108908ef40caf1202fcd8d54
+SHA512:
+  metadata.gz: 84b05d1d995acbb3ab9d78b71ffb49130490798f162788b04bfd91c95ea9b94ec71c0477e3d43b8aa0bf9c0e8815b90ffed06fa27c58987ac2d9491b10c777de
+  data.tar.gz: 9822db1173331febc6152cf567b61513fb0eadfb08a7a05240a31efc8ea9fed423fd8f5bfb37d8e2a9b1cef58e3a5abb66dc6418572bbdcca875818992581082

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2015-2025 Vendo Connect Inc., Vendo Sp. z o.o.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,59 @@
+# Spree Legacy product properties
+
+This is a Legacy product properties extension for [Spree Commerce](https://spreecommerce.org), an open source e-commerce platform built with Ruby on Rails.
+
+## Installation
+
+1. Add this extension to your Gemfile with this line:
+
+    ```ruby
+    bundle add spree_legacy_product_properties
+    ```
+
+2. Run the install generator
+
+    ```ruby
+    bundle exec rails g spree_legacy_product_properties:install
+    ```
+
+3. Restart your server
+
+  If your server was running, restart it so that it can find the assets properly.
+
+## Developing
+
+1. Create a dummy app
+
+    ```bash
+    bundle update
+    bundle exec rake test_app
+    ```
+
+2. Add your new code
+3. Run tests
+
+    ```bash
+    bundle exec rspec
+    ```
+
+When testing your applications integration with this extension you may use it's factories.
+Simply add this require statement to your spec_helper:
+
+```ruby
+require 'spree_legacy_product_properties/factories'
+```
+
+## Releasing a new version
+
+```shell
+bundle exec gem bump -p -t
+bundle exec gem release
+```
+
+For more options please see [gem-release README](https://github.com/svenfuchs/gem-release)
+
+## Contributing
+
+If you'd like to contribute, please take a look at the
+[instructions](CONTRIBUTING.md) for installing dependencies and crafting a good
+pull request.

data/Rakefile

@@ -0,0 +1,23 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'spree/testing_support/extension_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default do
+  if Dir['spec/dummy'].empty?
+    Rake::Task[:test_app].invoke
+    Dir.chdir('../../')
+  end
+  Rake::Task[:spec].invoke
+end
+
+desc 'Generates a dummy app for testing'
+task :test_app do
+  ENV['LIB_NAME'] = 'spree_legacy_product_properties'
+  Rake::Task['extension:test_app'].execute(
+    install_admin: true
+  )
+end

data/app/controllers/spree/admin/products_controller_decorator.rb

@@ -0,0 +1,26 @@
+module Spree
+  module Admin
+    module ProductsControllerDecorator
+      def self.prepended(base)
+        base.new_action.before :build_product_properties
+        base.edit_action.before :build_product_properties
+      end
+
+      private
+
+      def build_product_properties
+        return unless Spree::Config[:product_properties_enabled]
+
+        Spree::Property.all.each do |property|
+          @product.product_properties.build(property: property) unless @product.product_properties.find do |product_property|
+            product_property.property_id == property.id
+          end
+        end
+      end
+    end
+  end
+end
+
+if defined?(Spree::Admin::ProductsController)
+  Spree::Admin::ProductsController.prepend(Spree::Admin::ProductsControllerDecorator)
+end

data/app/controllers/spree/admin/properties_controller.rb

@@ -0,0 +1,26 @@
+module Spree
+  module Admin
+    class PropertiesController < ResourceController
+      include ProductsBreadcrumbConcern
+      add_breadcrumb Spree.t(:properties), :admin_properties_path
+
+      before_action :add_breadcrumbs
+
+      protected
+
+      def update_turbo_stream_enabled?
+        true
+      end
+
+      def add_breadcrumbs
+        if @property.present? && @property.persisted?
+          add_breadcrumb @property.presentation, spree.edit_admin_property_path(@property)
+        end
+      end
+
+      def permitted_resource_params
+        params.require(:property).permit(:name, :presentation, :position, :kind, :display_on)
+      end
+    end
+  end
+end

data/app/finders/spree/product_properties/find_available.rb

@@ -0,0 +1,20 @@
+module Spree
+  module ProductProperties
+    class FindAvailable
+      include ProductFilterable
+
+      def initialize(scope: ProductProperty.spree_base_scopes, products_scope: Product.spree_base_scopes)
+        @scope = scope
+        @products_scope = products_scope
+      end
+
+      def execute
+        find_available(scope, products_scope).includes(:translations)
+      end
+
+      private
+
+      attr_reader :scope, :products_scope
+    end
+  end
+end

data/app/finders/spree/products/find_decorator.rb

@@ -0,0 +1,47 @@
+module Spree
+  module Products
+    module FindDecorator
+      def initialize(scope:, params:)
+        @properties = params.dig(:filter, :properties)
+        super
+      end
+
+      def execute
+        products = super
+        # Apply property filtering after all other filters
+        by_properties(products)
+      end
+
+      private
+
+      attr_reader :properties
+
+      def properties?
+        properties.present? && properties.values.reject(&:empty?).present?
+      end
+
+      def by_properties(products)
+        return products unless properties?
+
+        product_ids = []
+        index = 0
+
+        properties.to_unsafe_hash.each do |property_filter_param, product_properties_values|
+          next if property_filter_param.blank? || product_properties_values.empty?
+
+          values = product_properties_values.split(',').reject(&:empty?).uniq.map(&:parameterize)
+
+          next if values.empty?
+
+          ids = scope.unscope(:order, :includes).with_property_values(property_filter_param, values).ids
+          product_ids = index == 0 ? ids : product_ids & ids
+          index += 1
+        end
+
+        products.where(id: product_ids)
+      end
+    end
+  end
+end
+
+Spree::Products::Find.prepend(Spree::Products::FindDecorator)

data/app/helpers/spree/admin/properties_helper.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Admin
+    module PropertiesHelper
+      def sorted_product_properties(product)
+        product.product_properties.sort_by_property_position
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Spree
+  module FilterParam
+    extend ActiveSupport::Concern
+
+    included do
+      before_save :set_filter_param
+    end
+
+    protected
+
+    def set_filter_param
+      return if param_candidate.blank?
+
+      self.filter_param = param_candidate.parameterize
+    end
+
+    def param_candidate
+      name
+    end
+  end
+end

data/app/models/spree/permission_sets/property_management.rb

@@ -0,0 +1,10 @@
+module Spree
+  module PermissionSets
+    class PropertyManagement < PermissionSets::Base
+      def activate!
+        can :manage, Spree::Property
+        can :manage, Spree::ProductProperty
+      end
+    end
+  end
+end

data/app/models/spree/product_decorator.rb

@@ -0,0 +1,107 @@
+module Spree
+  module ProductDecorator
+    def self.prepended(base)
+      base.has_many :product_properties, dependent: :destroy, inverse_of: :product
+      base.has_many :properties, through: :product_properties
+
+      base.accepts_nested_attributes_for :product_properties, allow_destroy: true, reject_if: lambda { |pp|
+        pp[:property_id].blank? || (pp[:id].blank? && pp[:value].blank?)
+      }
+
+      base.whitelisted_ransackable_associations |= %w[properties]
+
+      # Property scopes
+      base.add_search_scope :with_property do |property|
+        joins(:properties).where(Spree::Product.property_conditions(property))
+      end
+
+      base.add_search_scope :with_property_value do |property, value|
+        if Spree.use_translations?
+          joins(:properties).
+            join_translation_table(Spree::Property).
+            join_translation_table(Spree::ProductProperty).
+            where(Spree::ProductProperty.translation_table_alias => { value: value }).
+            where(Spree::Product.property_conditions(property))
+        else
+          joins(:properties).
+            where(Spree::ProductProperty.table_name => { value: value }).
+            where(Spree::Product.property_conditions(property))
+        end
+      end
+
+      base.add_search_scope :with_property_values do |property_filter_param, property_values|
+        joins(product_properties: :property).
+          where(Spree::Property.table_name => { filter_param: property_filter_param }).
+          where(Spree::ProductProperty.table_name => { filter_param: property_values.map(&:parameterize) })
+      end
+    end
+
+    def self.property_conditions(property)
+      properties_table = Spree::Property.table_name
+
+      case property
+      when Spree::Property then { "#{properties_table}.id" => property.id }
+      when Integer then { "#{properties_table}.id" => property }
+      else
+        if Spree::Property.column_for_attribute('id').type == :uuid
+          ["#{properties_table}.name = ? OR #{properties_table}.id = ?", property, property]
+        else
+          { "#{properties_table}.name" => property }
+        end
+      end
+    end
+
+    def property(property_name)
+      if product_properties.loaded?
+        product_properties.detect { |pp| pp.property.name == property_name }.try(:value)
+      else
+        product_properties.joins(:property).find_by(spree_properties: { name: property_name }).try(:value)
+      end
+    end
+
+    def set_property(property_name, property_value, property_presentation = property_name)
+      property_name = property_name.to_s.parameterize
+      ApplicationRecord.transaction do
+        prop = if Spree::Property.where(name: property_name).exists?
+                 existing_property = Spree::Property.where(name: property_name).first
+                 existing_property.presentation ||= property_presentation
+                 existing_property.save
+                 existing_property
+               else
+                 Spree::Property.create(name: property_name, presentation: property_presentation)
+               end
+
+        product_property = if Spree::ProductProperty.where(product: self, property: prop).exists?
+                             Spree::ProductProperty.where(product: self, property: prop).first
+                           else
+                             Spree::ProductProperty.new(product: self, property: prop)
+                           end
+
+        product_property.value = property_value
+        product_property.save!
+      end
+    end
+
+    def remove_property(property_name)
+      product_properties.joins(:property).find_by(spree_properties: { name: property_name.parameterize })&.destroy
+    end
+
+    def storefront_description
+      property('short_description') || description
+    end
+
+    private
+
+    def add_associations_from_prototype
+      if prototype_id && (prototype = Spree::Prototype.find_by(id: prototype_id))
+        prototype.properties.each do |prop|
+          product_properties.create(property: prop, value: 'Placeholder')
+        end
+        self.option_types = prototype.option_types
+        self.taxons = prototype.taxons
+      end
+    end
+  end
+end
+
+Spree::Product.prepend(Spree::ProductDecorator)

data/app/models/spree/product_property.rb

@@ -0,0 +1,51 @@
+module Spree
+  class ProductProperty < Spree.base_class
+    include Spree::FilterParam
+    include Spree::TranslatableResource
+
+    if Spree.always_use_translations?
+      TRANSLATABLE_FIELDS = %i[value filter_param].freeze
+      translates(*TRANSLATABLE_FIELDS)
+    else
+      TRANSLATABLE_FIELDS = %i[value].freeze
+      translates(*TRANSLATABLE_FIELDS, column_fallback: true)
+    end
+
+    self::Translation.class_eval do
+      normalizes :value, with: ->(value) { value&.to_s&.squish&.presence }
+    end
+
+    normalizes :value, with: ->(value) { value&.to_s&.squish&.presence }
+
+    acts_as_list scope: :product
+
+    with_options inverse_of: :product_properties do
+      belongs_to :product, touch: true, class_name: 'Spree::Product'
+      belongs_to :property, touch: true, class_name: 'Spree::Property'
+    end
+
+    validates :property, presence: true
+    validates :property_id, uniqueness: { scope: :product_id }
+    validates :value, presence: true
+
+    default_scope { order(:position) }
+
+    scope :filterable, -> { joins(:property).where(Property.table_name => { filterable: true }) }
+    scope :for_products, ->(products) { where(product_id: products) }
+    scope :sort_by_property_position, -> {
+      unscope(:order).joins(:property).order(Spree::Property.table_name => { position: :asc })
+    }
+
+    self.whitelisted_ransackable_attributes = ['value', 'filter_param']
+    self.whitelisted_ransackable_associations = ['property']
+
+    # virtual attributes for use with AJAX completion stuff
+    delegate :name, :presentation, to: :property, prefix: true, allow_nil: true
+
+    protected
+
+    def param_candidate
+      value
+    end
+  end
+end

data/app/models/spree/products/duplicator_decorator.rb

@@ -0,0 +1,29 @@
+module Spree
+  module Products
+    module DuplicatorDecorator
+      def call(product:, include_images: true)
+        result = super
+        return result unless result.success?
+
+        new_product = result.value
+        new_product.product_properties = duplicate_properties(product.product_properties) if new_product.persisted?
+
+        result
+      end
+
+      protected
+
+      def duplicate_properties(product_properties)
+        product_properties.map do |prop|
+          new_prop = prop.dup
+          new_prop.product = nil
+          new_prop.created_at = nil
+          new_prop.updated_at = nil
+          new_prop
+        end
+      end
+    end
+  end
+end
+
+Spree::Products::Duplicator.prepend(Spree::Products::DuplicatorDecorator)

data/app/models/spree/property.rb

@@ -0,0 +1,86 @@
+module Spree
+  class Property < Spree.base_class
+    include Spree::FilterParam
+    include Spree::Metadata
+    include Spree::ParameterizableName
+    include Spree::UniqueName
+    include Spree::DisplayOn
+    include Spree::TranslatableResource
+
+    TRANSLATABLE_FIELDS = %i[presentation].freeze
+    translates(*TRANSLATABLE_FIELDS, column_fallback: !Spree.always_use_translations?)
+
+    self::Translation.class_eval do
+      normalizes :presentation, with: ->(value) { value&.to_s&.squish&.presence }
+    end
+
+    acts_as_list
+
+    has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
+    has_many :prototypes, through: :property_prototypes, class_name: 'Spree::Prototype'
+
+    has_many :product_properties, dependent: :delete_all, inverse_of: :property
+    has_many :products, through: :product_properties
+
+    validates :name, :presentation, presence: true
+
+    default_scope { order(:position) }
+    scope :sorted, -> { order(:name) }
+    scope :filterable, -> { where(filterable: true) }
+
+    KIND_OPTIONS = { short_text: 0, long_text: 1, number: 2, rich_text: 3 }.freeze
+    enum :kind, KIND_OPTIONS
+
+    DEPENDENCY_UPDATE_FIELDS = [:presentation, :name, :kind, :filterable, :display_on, :position].freeze
+
+    after_touch :touch_all_products
+    after_update :touch_all_products, if: -> { DEPENDENCY_UPDATE_FIELDS.any? { |field| saved_changes.key?(field) } }
+    after_save :ensure_product_properties_have_filter_params
+
+    self.whitelisted_ransackable_attributes = ['presentation', 'filterable']
+
+    def uniq_values(product_properties_scope: nil)
+      with_uniq_values_cache_key(product_properties_scope) do
+        properties = product_properties
+        properties = properties.where(id: product_properties_scope) if product_properties_scope.present?
+        properties.where('value IS NOT NULL AND value != ?', '').pluck(:filter_param, :value).uniq
+      end
+    end
+
+    # Returns the metafield type for the property kind
+    # @return [String] eg. 'Spree::Metafields::ShortText'
+    def kind_to_metafield_type
+      case kind
+      when 'short_text'
+        'Spree::Metafields::ShortText'
+      when 'long_text'
+        'Spree::Metafields::LongText'
+      when 'number'
+        'Spree::Metafields::Number'
+      when 'rich_text'
+        'Spree::Metafields::RichText'
+      else
+        'Spree::Metafields::ShortText'
+      end
+    end
+
+    private
+
+    def touch_all_products
+      products.touch_all
+    end
+
+    def with_uniq_values_cache_key(product_properties_scope, &block)
+      return block.call if product_properties_scope.present?
+
+      uniq_values_cache_key = ['property-uniq-values', cache_key_with_version]
+      Rails.cache.fetch(uniq_values_cache_key) { block.call }
+    end
+
+    def ensure_product_properties_have_filter_params
+      return unless filterable?
+
+      product_properties.where(filter_param: [nil, '']).where('value IS NOT NULL AND value != ?', '').find_each(&:save)
+    end
+  end
+end

data/app/models/spree/property_prototype.rb

@@ -0,0 +1,9 @@
+module Spree
+  class PropertyPrototype < Spree.base_class
+    belongs_to :prototype, class_name: 'Spree::Prototype'
+    belongs_to :property, class_name: 'Spree::Property'
+
+    validates :prototype, :property, presence: true
+    validates :prototype_id, uniqueness: { scope: :property_id }
+  end
+end

data/app/models/spree/prototype_decorator.rb

@@ -0,0 +1,10 @@
+module Spree
+  module PrototypeDecorator
+    def self.prepended(base)
+      base.has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
+      base.has_many :properties, through: :property_prototypes, class_name: 'Spree::Property'
+    end
+  end
+end
+
+Spree::Prototype.prepend(Spree::PrototypeDecorator)

data/app/presenters/spree/filters/properties_presenter.rb

@@ -0,0 +1,23 @@
+module Spree
+  module Filters
+    class PropertiesPresenter
+      def initialize(product_properties_scope:)
+        @product_properties = product_properties_scope.includes(:property)
+      end
+
+      def to_a
+        grouped_options.map do |property, product_properties|
+          PropertyPresenter.new(property: property, product_properties: product_properties)
+        end
+      end
+
+      private
+
+      attr_reader :product_properties
+
+      def grouped_options
+        product_properties.group_by(&:property)
+      end
+    end
+  end
+end

data/app/presenters/spree/filters/property_presenter.rb

@@ -0,0 +1,42 @@
+module Spree
+  module Filters
+    class PropertyPresenter
+      def initialize(property:, product_properties:)
+        @property = property
+        @product_properties = product_properties
+      end
+
+      attr_reader :product_properties
+
+      delegate_missing_to :property
+
+      def uniq_values
+        property.uniq_values(product_properties_scope: product_properties)
+      end
+
+      def to_h
+        {
+          id: property.id,
+          name: property.name,
+          presentation: property.presentation,
+          values: values_hash
+        }
+      end
+
+      private
+
+      attr_reader :property
+
+      def values_hash
+        value_hashes = uniq_values.map do |filter_param, value|
+          {
+            value: value,
+            filter_param: filter_param
+          }
+        end
+
+        value_hashes.sort_by { |e| e[:value] }
+      end
+    end
+  end
+end

data/app/services/spree/products/prepare_nested_attributes_decorator.rb

@@ -0,0 +1,22 @@
+module Spree
+  module Products
+    module PrepareNestedAttributesDecorator
+      def call
+        # Mark product properties for removal when value is left blank
+        if params[:product_properties_attributes].present?
+          params[:product_properties_attributes].each do |key, product_property_params|
+            next unless product_property_params[:id].present?
+            next if product_property_params[:value].present?
+
+            # https://api.rubyonrails.org/v7.1.3.4/classes/ActiveRecord/NestedAttributes/ClassMethods.html
+            params[:product_properties_attributes][key]['_destroy'] = '1'
+          end
+        end
+
+        super
+      end
+    end
+  end
+end
+
+Spree::Products::PrepareNestedAttributes.prepend(Spree::Products::PrepareNestedAttributesDecorator)

data/app/views/spree/admin/products/form/_properties.html.erb

@@ -0,0 +1,48 @@
+<% if Spree::Config[:product_properties_enabled] %>
+<div class="card mb-6">
+  <div class="card-header flex items-center justify-between">
+    <h5 class="card-title"><%= Spree.t(:properties) %></h5>
+
+    <% if can?(:manage, Spree::Property) %>
+      <%= link_to_with_icon 'adjustments', Spree.t('admin.manage_properties'), spree.admin_properties_path, class: 'btn btn-sm btn-light' %>
+    <% end %>
+  </div>
+  <div class="card-body p-0">
+    <table class="table">
+      <thead>
+        <tr>
+          <th scope="col"><%= Spree.t(:property) %></th>
+          <th scope="col"><%= Spree.t(:value) %></th>
+        </tr>
+      </thead>
+      <tbody>
+        <%= f.fields_for :product_properties, sorted_product_properties(f.object) do |product_property_form| %>
+          <% property = product_property_form.object.property %>
+          <%= product_property_form.hidden_field :id %>
+          <%= product_property_form.hidden_field :property_id %>
+          <tr>
+            <td class="align-top pt-4 w-1/4">
+              <code><%= property.name %></code>
+            </td>
+            <td class="w-3/4">
+              <div class="form-group">
+                <% if property.long_text? %>
+                  <%= product_property_form.text_area :value, { class: 'form-input', data: { controller: 'textarea-autogrow'} } %>
+                <% elsif property.number? %>
+                  <%= product_property_form.number_field :value, class: 'form-input' %>
+                <% elsif property.rich_text? %>
+                  <div class="trix-container">
+                    <%= product_property_form.rich_text_area :value %>
+                  </div>
+                <% else %>
+                  <%= product_property_form.text_field :value, class: 'form-input' %>
+                <% end %>
+              </div>
+            </td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  </div>
+</div>
+<% end %>

data/app/views/spree/admin/properties/_filters.html.erb

@@ -0,0 +1,5 @@
+<%= search_form_for [:admin, @search], class: "filter-wrap", data: {controller: "filters"} do |f| %>
+  <%= render 'spree/admin/shared/filters_search_bar', param: :name_cont, label: Spree.t(:name) %>
+  <%= render "spree/admin/shared/filter_badge_template" %>
+  <div data-filters-target="badgesContainer" class="filter-badges-container"></div>
+<% end %>

data/app/views/spree/admin/properties/_form.html.erb

@@ -0,0 +1,8 @@
+<div data-controller="slug-form" class="card mb-6">
+  <div class="card-body">
+    <%= f.spree_text_field :presentation, data: { slug_form_target: :name, action: 'input->slug-form#updateUrlFromName' }, required: true, autofocus: f.object.new_record? %>
+    <%= f.spree_text_field :name, label: Spree.t(:internal_name), data: { slug_form_target: :url }, required: true %>
+    <%= f.spree_select :kind, options_for_select(Spree::Property.kinds.map{ |k| [k.first.humanize, k.first.to_sym] }, @object.kind) %>
+    <%= f.spree_select :display_on, display_on_options, { label: Spree.t(:display_on) } %>
+  </div>
+</div>

data/app/views/spree/admin/properties/_table_header.html.erb

@@ -0,0 +1,9 @@
+<tr>
+  <th class="no-border handel-head"></th>
+  <th scope="col"><%= Spree.t(:internal_name) %></th>
+  <th scope="col"><%= Spree.t(:presentation) %></th>
+  <th scope="col"><%= Spree.t(:kind) %></th>
+  <th scope="col"><%= Spree.t(:products) %></th>
+  <th scope="col"><%= Spree.t(:visibility) %></th>
+  <th scope="col"></th>
+</tr>

data/app/views/spree/admin/properties/_table_row.html.erb

@@ -0,0 +1,25 @@
+<tr id="<%= spree_dom_id property %>" data-controller="row-link" data-sortable-update-url="<%= spree.admin_property_path(property) %>">
+  <td class="w-5 move-handle text-center">
+    <%= icon('grip-vertical', class: 'rounded-md hover:bg-gray-100 p-2') %>
+  </td>
+  <td class="w-20 cursor-pointer py-0" data-action="click->row-link#openLink">
+    <code><%= property.name %></code>
+  </td>
+  <td class="w-20 cursor-pointer" data-action="click->row-link#openLink">
+    <%= link_to property.presentation, spree.edit_admin_property_path(property), class: 'no-underline flex items-center font-bold text-gray-900', data: { row_link_target: :link, turbo_frame: '_top' } %>
+  </td>
+  <td class="w-20 cursor-pointer" data-action="click->row-link#openLink">
+    <span class="badge badge-light"><%= property.kind.humanize %></span>
+  </td>
+  <td class="w-10 cursor-pointer" data-action="click->row-link#openLink">
+    <%= property.products.count %>
+  </td>
+  <td>
+    <%= form_with model: property, url: admin_property_path(property), method: :patch, data: { controller: 'auto-submit' } do |f| %>
+      <%= f.select :display_on, display_on_options, {}, { class: 'form-select form-select-sm', data: { action: 'auto-submit#submit' } } %>
+    <% end %>
+  </td>
+  <td class="w-10 actions">
+    <%= link_to_edit(property, class: 'btn btn-light btn-sm', data: { turbo_frame: '_top' }) if can?(:edit, property) %>
+  </td>
+</tr>

data/app/views/spree/admin/properties/edit.html.erb

@@ -0,0 +1,2 @@
+
+<%= render 'spree/admin/shared/edit_resource' %>

data/app/views/spree/admin/properties/index.html.erb

@@ -0,0 +1,22 @@
+<% content_for(:page_title) do %>
+  <%= Spree.t(:properties) %>
+<% end %>
+
+<% content_for(:page_alerts) do %>
+  <div class="alert alert-info">
+    Properties allow you to enrich your Product information.
+  </div>
+<% end %>
+
+<% content_for :page_actions do %>
+  <%= render_admin_partials(:properties_actions_partials) %>
+  <%= link_to_with_icon 'plus', Spree.t(:new_property), new_object_url, class: "btn btn-primary" if can?(:create, Spree::Property) %>
+<% end  %>
+
+<%= render_admin_partials(:properties_header_partials) %>
+
+<%= render 'spree/admin/shared/index_table', sortable: true %>
+
+<p class="documentation-link-container">
+  <%= external_link_to "Learn more about properties", "https://spreecommerce.org/docs/user/manage-products/product-properties" %>
+</p>

data/app/views/spree/admin/properties/new.html.erb

@@ -0,0 +1 @@
+<%= render 'spree/admin/shared/new_resource' %>

data/app/views/spree/admin/properties/update.turbo_stream.erb

@@ -0,0 +1 @@
+<%= turbo_render_alerts %>

data/config/initializers/spree.rb

@@ -0,0 +1,62 @@
+Rails.application.config.after_initialize do
+  # Register product_properties_enabled preference if not already defined
+  unless Spree::Config.respond_to?(:product_properties_enabled)
+    Spree::Core::Configuration.preference :product_properties_enabled, :boolean, default: false
+  end
+
+  # Register permitted attributes for product properties
+  unless Spree::PermittedAttributes::ATTRIBUTES.include?(:product_properties_attributes)
+    Spree::PermittedAttributes::ATTRIBUTES.push(:product_properties_attributes, :property_attributes)
+
+    Spree::PermittedAttributes.class_eval do
+      mattr_accessor :product_properties_attributes
+      mattr_accessor :property_attributes
+    end
+
+    Spree::PermittedAttributes.product_properties_attributes = [
+      :property_name, :property_id, :value, :position, :_destroy
+    ]
+    Spree::PermittedAttributes.property_attributes = [
+      :name, :presentation, :position, :kind, :display_on
+    ]
+
+    # Re-delegate the new attributes
+    Spree::Core::ControllerHelpers::StrongParameters.delegate(
+      :permitted_product_properties_attributes,
+      :permitted_property_attributes,
+      to: :permitted_attributes,
+      prefix: false
+    )
+  end
+
+  # Override permitted_product_attributes to include product_properties_attributes
+  Spree::Core::ControllerHelpers::StrongParameters.module_eval do
+    def permitted_product_attributes
+      permitted_attributes.product_attributes + [
+        variants_attributes: permitted_variant_attributes + ['id', :_destroy],
+        master_attributes: permitted_variant_attributes + ['id'],
+        product_properties_attributes: permitted_product_properties_attributes + ['id', :_destroy]
+      ]
+    end
+  end
+
+  # Register product form partial for properties
+  if defined?(Spree::Admin) && Rails.application.config.respond_to?(:spree_admin)
+    Rails.application.config.spree_admin.product_form_partials << 'spree/admin/products/form/properties'
+  end
+
+  # Register admin navigation
+  if defined?(Spree::Admin) && Spree.respond_to?(:admin)
+    sidebar_nav = Spree.admin.navigation.sidebar
+
+    products_item = sidebar_nav.find(:products)
+    if products_item
+      builder = Spree::Admin::Navigation::Builder.new(sidebar_nav, products_item)
+      builder.add :properties,
+                  label: :properties,
+                  url: :admin_properties_path,
+                  position: 50,
+                  if: -> { can?(:manage, Spree::Property) && Spree::Config.product_properties_enabled }
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,5 @@
+Spree::Core::Engine.add_routes do
+  namespace :admin, path: Spree.admin_path do
+    resources :properties, except: :show
+  end
+end

data/db/migrate/20221229000000_create_spree_properties_and_product_properties.rb

@@ -0,0 +1,113 @@
+class CreateSpreePropertiesAndProductProperties < ActiveRecord::Migration[7.2]
+  def json_column_type
+    connection.adapter_name.downcase.include?('postgresql') ? :jsonb : :json
+  end
+
+  def change
+    unless table_exists?(:spree_properties)
+      create_table :spree_properties do |t|
+        t.string :name
+        t.string :presentation, null: false
+        t.string :filter_param
+        t.boolean :filterable, default: false, null: false
+        t.integer :kind, default: 0
+        t.string :display_on, default: 'both'
+        t.integer :position, default: 0
+        t.column :public_metadata, json_column_type
+        t.column :private_metadata, json_column_type
+
+        t.timestamps
+      end
+
+      add_index :spree_properties, :name, unique: true
+      add_index :spree_properties, :filter_param
+      add_index :spree_properties, :filterable
+      add_index :spree_properties, :position
+    end
+
+    unless table_exists?(:spree_product_properties)
+      create_table :spree_product_properties do |t|
+        t.string :value
+        t.references :product, null: false
+        t.references :property, null: false
+        t.integer :position, default: 0
+        t.string :filter_param
+        t.boolean :show_property, default: true
+
+        t.timestamps
+      end
+
+      add_index :spree_product_properties, [:property_id, :product_id], unique: true
+      add_index :spree_product_properties, :filter_param
+      add_index :spree_product_properties, :position
+    end
+
+    unless table_exists?(:spree_property_prototypes)
+      create_table :spree_property_prototypes do |t|
+        t.references :prototype
+        t.references :property
+
+        t.timestamps
+      end
+
+      add_index :spree_property_prototypes, [:prototype_id, :property_id], unique: true, name: 'index_property_prototypes_on_prototype_id_and_property_id'
+    end
+
+    unless table_exists?(:spree_property_translations)
+      create_table :spree_property_translations do |t|
+        t.references :spree_property, null: false
+        t.string :locale, null: false
+        t.string :presentation
+
+        t.timestamps
+      end
+
+      add_index :spree_property_translations, :locale
+      add_index :spree_property_translations, [:spree_property_id, :locale], unique: true, name: 'unique_property_id_per_locale'
+    end
+
+    unless table_exists?(:spree_product_property_translations)
+      create_table :spree_product_property_translations do |t|
+        t.references :spree_product_property, null: false
+        t.string :locale, null: false
+        t.string :value
+
+        t.timestamps
+      end
+
+      add_index :spree_product_property_translations, :locale
+      add_index :spree_product_property_translations, [:spree_product_property_id, :locale], unique: true, name: 'unique_product_property_id_per_locale'
+    end
+
+    # For existing installations that already have these tables but may be missing columns
+    if table_exists?(:spree_properties)
+      unless column_exists?(:spree_properties, :public_metadata)
+        add_column :spree_properties, :public_metadata, json_column_type
+      end
+
+      unless column_exists?(:spree_properties, :private_metadata)
+        add_column :spree_properties, :private_metadata, json_column_type
+      end
+
+      unless column_exists?(:spree_properties, :display_on)
+        add_column :spree_properties, :display_on, :string, default: 'both'
+      end
+
+      unless column_exists?(:spree_properties, :position)
+        add_column :spree_properties, :position, :integer, default: 0
+      end
+
+      unless column_exists?(:spree_properties, :kind)
+        add_column :spree_properties, :kind, :integer, default: 0
+      end
+
+      unless column_exists?(:spree_properties, :filter_param)
+        add_column :spree_properties, :filter_param, :string
+      end
+
+      unless column_exists?(:spree_properties, :filterable)
+        add_column :spree_properties, :filterable, :boolean, default: false, null: false
+      end
+    end
+  end
+end

data/lib/generators/spree_legacy_product_properties/install/install_generator.rb

@@ -0,0 +1,20 @@
+module SpreeLegacyProductProperties
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      class_option :migrate, type: :boolean, default: true
+
+      def add_migrations
+        run 'bundle exec rake railties:install:migrations FROM=spree_legacy_product_properties'
+      end
+
+      def run_migrations
+        run_migrations = options[:migrate] || ['', 'y', 'Y'].include?(ask('Would you like to run the migrations now? [Y/n]'))
+        if run_migrations
+          run 'bin/rails db:migrate'
+        else
+          puts 'Skipping rails db:migrate, don\'t forget to run it!'
+        end
+      end
+    end
+  end
+end

data/lib/spree_legacy_product_properties/configuration.rb

@@ -0,0 +1,13 @@
+module SpreeLegacyProductProperties
+  class Configuration < Spree::Preferences::Configuration
+
+   # Some example preferences are shown below, for more information visit:
+   # https://docs.spreecommerce.org/developer/contributing/creating-an-extension
+
+   # preference :enabled, :boolean, default: true
+   # preference :dark_chocolate, :boolean, default: true
+   # preference :color, :string, default: 'Red'
+   # preference :favorite_number, :integer
+   # preference :supported_locales, :array, default: [:en]
+  end
+end

data/lib/spree_legacy_product_properties/engine.rb

@@ -0,0 +1,23 @@
+module SpreeLegacyProductProperties
+  class Engine < Rails::Engine
+    require 'spree/core'
+    isolate_namespace Spree
+    engine_name 'spree_legacy_product_properties'
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    initializer 'spree_legacy_product_properties.environment', before: :load_config_initializers do |_app|
+      SpreeLegacyProductProperties::Config = SpreeLegacyProductProperties::Configuration.new
+    end
+
+    def self.activate
+      Dir.glob(File.join(File.dirname(__FILE__), '../../app/**/*_decorator*.rb')) do |c|
+        Rails.configuration.cache_classes ? require(c) : load(c)
+      end
+    end
+
+    config.to_prepare(&method(:activate).to_proc)
+  end
+end

data/lib/spree_legacy_product_properties/factories.rb

@@ -0,0 +1,34 @@
+FactoryBot.define do
+  factory :property, class: Spree::Property do
+    sequence(:name) { |n| "baseball_cap_color_#{n}" }
+    presentation { 'cap color' }
+
+    trait :filterable do
+      filterable { true }
+    end
+
+    trait :brand do
+      name         { 'brand' }
+      presentation { 'Brand' }
+      filter_param { 'brand' }
+    end
+
+    trait :manufacturer do
+      name         { 'manufacturer' }
+      presentation { 'Manufacturer' }
+      filter_param { 'manufacturer' }
+    end
+
+    trait :material do
+      name         { 'material' }
+      presentation { 'Material' }
+      filter_param { 'material' }
+    end
+  end
+
+  factory :product_property, class: Spree::ProductProperty do
+    product
+    value { "val-#{rand(50)}" }
+    property
+  end
+end

data/lib/spree_legacy_product_properties/version.rb

@@ -0,0 +1,7 @@
+module SpreeLegacyProductProperties
+  VERSION = '1.0.0'.freeze
+
+  def gem_version
+    Gem::Version.new(VERSION)
+  end
+end

data/lib/spree_legacy_product_properties.rb

@@ -0,0 +1,12 @@
+require 'spree'
+require 'spree_legacy_product_properties/engine'
+require 'spree_legacy_product_properties/version'
+require 'spree_legacy_product_properties/configuration'
+
+module SpreeLegacyProductProperties
+  mattr_accessor :queue
+
+  def self.queue
+    @@queue ||= Spree.queues.default
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: spree_legacy_product_properties
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Vendo Connect Inc., Vendo Sp. z o.o.
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: spree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.4.0.beta
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.4.0.beta
+- !ruby/object:Gem::Dependency
+  name: spree_admin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.4.0.beta
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.4.0.beta
+- !ruby/object:Gem::Dependency
+  name: spree_dev_tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Legacy product properties system extracted from Spree core. Replaced
+  by Metafields in Spree 5.x.
+email: hello@spreecommerce.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- Rakefile
+- app/controllers/spree/admin/products_controller_decorator.rb
+- app/controllers/spree/admin/properties_controller.rb
+- app/finders/spree/product_properties/find_available.rb
+- app/finders/spree/products/find_decorator.rb
+- app/helpers/spree/admin/properties_helper.rb
+- app/models/concerns/spree/filter_param.rb
+- app/models/spree/permission_sets/property_management.rb
+- app/models/spree/product_decorator.rb
+- app/models/spree/product_property.rb
+- app/models/spree/products/duplicator_decorator.rb
+- app/models/spree/property.rb
+- app/models/spree/property_prototype.rb
+- app/models/spree/prototype_decorator.rb
+- app/presenters/spree/filters/properties_presenter.rb
+- app/presenters/spree/filters/property_presenter.rb
+- app/services/spree/products/prepare_nested_attributes_decorator.rb
+- app/views/spree/admin/products/form/_properties.html.erb
+- app/views/spree/admin/properties/_filters.html.erb
+- app/views/spree/admin/properties/_form.html.erb
+- app/views/spree/admin/properties/_table_header.html.erb
+- app/views/spree/admin/properties/_table_row.html.erb
+- app/views/spree/admin/properties/edit.html.erb
+- app/views/spree/admin/properties/index.html.erb
+- app/views/spree/admin/properties/new.html.erb
+- app/views/spree/admin/properties/update.turbo_stream.erb
+- config/initializers/spree.rb
+- config/routes.rb
+- db/migrate/20221229000000_create_spree_properties_and_product_properties.rb
+- lib/generators/spree_legacy_product_properties/install/install_generator.rb
+- lib/spree_legacy_product_properties.rb
+- lib/spree_legacy_product_properties/configuration.rb
+- lib/spree_legacy_product_properties/engine.rb
+- lib/spree_legacy_product_properties/factories.rb
+- lib/spree_legacy_product_properties/version.rb
+homepage: https://github.com/spree/spree-legacy-product-properties
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- none
+rubygems_version: 4.0.2
+specification_version: 4
+summary: Legacy Product Properties for Spree Commerce
+test_files: []