alchemy-solidus 7.5.1 → 7.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 286c4a4ae1a6aba7c83ecc17b9f51e06b2e4b3cf7504382970edaed1c4de9ef1
-  data.tar.gz: fd623314a68027a9a1cd6bcd49067e0891a6342364f140668217f2c3fa339d7c
+  metadata.gz: 143befa0b406d415141a772a96b1b8203914f8826ba3bfeab814753525ce9808
+  data.tar.gz: ebd5ffbb9ecc0049e43b15e7a685eb7fe0fb729f54702ced9448827811ef02c5
 SHA512:
-  metadata.gz: 541d7bda1ff72e631923ab176dcd868c3f5bb16716a6e0eb0592a0749a9fef22f08f043c2b8393e9ce0a6e82ac2fcf919fb9fc5de621ddc452146e22d8045060
-  data.tar.gz: 3d260407d78557bda063934ac4105ff8f7357a40f0a9b25313608a8a5f256cc7eb2a739eb3775ec924cbd0c3dc9e7765da950936e2fba57ccda68fc7af1272d4
+  metadata.gz: e2d5614f2d2279cdd6905bfeef1e396d6d9b4e4913aeb843527f1e0c678dcfde1094e5a9dae7ea7c80d96883999bae0a12e83dcbf85b84d52a36b667d3e179da
+  data.tar.gz: 23cab9eee9c6ceb74acf1510edf65386ab57c931c3d0cb226b02c6b37a9bd41c9e104525a75da01431b380d7e7a2290dca1a9b4b7cdce45ab662325814ebb8a9

data/README.md

@@ -194,32 +194,6 @@ $ bundle exec rake alchemy:install
 
 and follow the on screen instructions.
 
-### Render Alchemy Content in Solidus Layout
-
-~~If you plan to render the Alchemy site in the Solidus layout add the following
-to your initializer:~~
-
-```ruby
-# config/initializers/alchemy.rb
-require 'alchemy/solidus/use_solidus_layout'
-```
-
-**NOTE:** Since v2.5.2 this is done automatically for you. If you upgraded from an older version you can safely remove this from your initializers.
-
-### Render Alchemy Content in Solidus views
-
-~~If you plan to render Alchemy content in your Solidus views (ie. a global header
-or footer section), you need to include the Alchemy view helpers and language
-store in your Solidus controllers with the following addition to your
-initializer:~~
-
-```ruby
-# config/initializers/alchemy.rb
-require 'alchemy/solidus/alchemy_in_solidus'
-```
-
-**NOTE:** Since v2.5.2 this is done automatically for you. If you upgraded from an older version you can safely remove this from your initializers.
-
 ### Routing
 
 For routing you have a few options.

data/app/components/alchemy/admin/link_dialog/product_tab.rb

@@ -47,7 +47,8 @@ module Alchemy
           select = render self.class.product_select_class.new(
             current_alchemy_user.spree_api_key,
             product: product,
-            url: spree.api_products_path
+            url: spree.api_products_path,
+            value_attribute: :slug
           ).with_content(input)
           content_tag("div", label + select, class: "input select")
         end

data/app/components/alchemy/admin/product_select.rb

@@ -1,15 +1,19 @@
 module Alchemy
   module Admin
     class ProductSelect < ViewComponent::Base
+      VALUE_ATTRIBUTES = %i[id slug].freeze
+
       delegate :spree, to: :helpers
 
-      attr_reader :api_key, :product, :url, :query_params
+      attr_reader :api_key, :product, :url, :query_params, :placeholder
 
-      def initialize(api_key, product: nil, url: nil, query_params: nil)
+      def initialize(api_key, product: nil, url: nil, query_params: nil, placeholder: nil, value_attribute: nil)
         @api_key = api_key
         @product = product
         @url = url
         @query_params = query_params
+        @placeholder = placeholder
+        @value_attribute = value_attribute
       end
 
       def call
@@ -18,9 +22,15 @@ module Alchemy
 
       private
 
+      def value_attribute
+        @value_attribute.in?(VALUE_ATTRIBUTES) ? @value_attribute : :id
+      end
+
       def attributes
         attrs = {
+          placeholder: placeholder || Alchemy.t(:search_product, scope: "solidus"),
           url: url || spree.api_products_path,
+          "value-attribute": value_attribute,
           "api-key": api_key
         }
 
@@ -35,8 +45,8 @@ module Alchemy
 
       def serialized_selection
         {
-          name: product.name,
-          slug: product.slug
+          id: product.send(value_attribute),
+          name: product.name
         }.to_json
       end
     end

data/app/components/alchemy/admin/taxon_select.rb

@@ -0,0 +1,46 @@
+module Alchemy
+  module Admin
+    class TaxonSelect < ViewComponent::Base
+      delegate :spree, to: :helpers
+
+      attr_reader :api_key, :taxon, :url, :query_params, :placeholder
+
+      def initialize(api_key, taxon: nil, url: nil, query_params: nil, placeholder: nil)
+        @api_key = api_key
+        @taxon = taxon
+        @url = url
+        @query_params = query_params
+        @placeholder = placeholder
+      end
+
+      def call
+        content_tag("alchemy-taxon-select", content, attributes)
+      end
+
+      private
+
+      def attributes
+        attrs = {
+          url: url || spree.api_taxons_path,
+          placeholder: placeholder || Alchemy.t(:search_taxon, scope: :solidus),
+          "api-key": api_key
+        }
+
+        attrs[:"query-params"] = query_params.to_json if query_params
+
+        if taxon
+          attrs[:selection] = serialized_selection
+        end
+
+        attrs
+      end
+
+      def serialized_selection
+        {
+          id: taxon.id,
+          text: taxon.pretty_name
+        }.to_json
+      end
+    end
+  end
+end

data/app/components/alchemy/admin/variant_select.rb

@@ -0,0 +1,48 @@
+module Alchemy
+  module Admin
+    class VariantSelect < ViewComponent::Base
+      delegate :spree, to: :helpers
+
+      attr_reader :api_key, :variant, :url, :query_params, :placeholder
+
+      def initialize(api_key, variant: nil, url: nil, query_params: nil, placeholder: nil)
+        @api_key = api_key
+        @variant = variant
+        @url = url
+        @query_params = query_params
+        @placeholder = placeholder
+      end
+
+      def call
+        content_tag("alchemy-variant-select", content, attributes)
+      end
+
+      private
+
+      def attributes
+        attrs = {
+          url: url || spree.api_variants_path,
+          placeholder: placeholder || Alchemy.t(:search_variant, scope: :solidus),
+          "api-key": api_key
+        }
+
+        attrs[:"query-params"] = query_params.to_json if query_params
+
+        if variant
+          attrs[:selection] = serialized_selection
+        end
+
+        attrs
+      end
+
+      def serialized_selection
+        {
+          id: variant.id,
+          name: variant.name,
+          sku: variant.sku,
+          options_text: variant.options_text
+        }.to_json
+      end
+    end
+  end
+end

data/app/javascript/alchemy_solidus/components/ajax_config.js

@@ -0,0 +1,10 @@
+export default function ajaxConfig(ajaxConfig, apiKey) {
+  return {
+    ...ajaxConfig,
+    params: {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+      },
+    },
+  }
+}

data/app/javascript/alchemy_solidus/components/product_select.js

@@ -1,42 +1,71 @@
-import "alchemy_solidus/product_select"
-
-export default class ProductSelect extends HTMLElement {
-  connectedCallback() {
-    const input = this.querySelector("#product_link")
-    input.classList.add("alchemy_selectbox")
-
-    $(input).alchemyProductSelect({
-      baseUrl: this.url,
-      apiToken: this.apiToken,
-      initSelection: this._initSelection.bind(this),
-      formatResultObject: this._formatResult.bind(this),
-    })
-  }
+import { RemoteSelect } from "alchemy_admin/components/remote_select"
+import ajaxConfig from "alchemy_solidus/components/ajax_config"
 
-  get url() {
-    return this.getAttribute("url")
+export default class ProductSelect extends RemoteSelect {
+  get ajaxConfig() {
+    return ajaxConfig(super.ajaxConfig, this.apiKey)
   }
 
-  get apiToken() {
+  get apiKey() {
     return this.getAttribute("api-key")
   }
 
-  _initSelection(_$el, callback) {
-    const selection = this.getAttribute("selection")
-    const product = JSON.parse(selection)
-    callback(this._formatResult(product))
+  get valueAttribute() {
+    return this.getAttribute("value-attribute") || "id"
   }
 
-  _formatResult(product) {
+  /**
+   * Parses server response into select2 results object
+   * @param {object} response
+   * @returns {object}
+   * @private
+   */
+  _parseResponse(response) {
     return {
-      id: `${Spree.mountedAt()}products/${product.slug}`,
-      text: product.name,
+      results: response.products.map((product) => {
+        return {
+          id: this._parsedValue(product),
+          name: product.name,
+        }
+      }),
+      more: response.current_page * response.per_page < response.total_count,
     }
   }
 
-  _searchQuery(value) {
-    const slug = value.replace(`${Spree.mountedAt()}products/`, "")
-    return `q[slug_eq]=${slug}`
+  /**
+   * The value used for the select send to the server
+   * after submitting the form this select is placed in.
+   *
+   * Note: Returning an url if the `value-attribute` is "slug".
+   *
+   * @param {object} product
+   * @returns {string}
+   */
+  _parsedValue(product) {
+    return this.valueAttribute === "slug"
+      ? `${Spree.mountedAt()}products/${product.slug}`
+      : product.id
+  }
+
+  /**
+   * result which is visible if a product was selected
+   * @param {object} product
+   * @returns {string}
+   * @private
+   */
+  _renderResult(product) {
+    return product.name
+  }
+
+  /**
+   * html template for each list entry
+   * @param {object} product
+   * @param {string} term
+   * @returns {string}
+   * @private
+   */
+  _renderListEntry(product, term) {
+    return this._hightlightTerm(product.name, term)
   }
 }
 

data/app/javascript/alchemy_solidus/components/taxon_select.js

@@ -0,0 +1,48 @@
+import { RemoteSelect } from "alchemy_admin/components/remote_select"
+import ajaxConfig from "alchemy_solidus/components/ajax_config"
+
+export default class TaxonSelect extends RemoteSelect {
+  get ajaxConfig() {
+    return ajaxConfig(super.ajaxConfig, this.apiKey)
+  }
+
+  get apiKey() {
+    return this.getAttribute("api-key")
+  }
+
+  /**
+   * Parses server response into select2 results object
+   * @param {object} response
+   * @returns {object}
+   * @private
+   */
+  _parseResponse(response) {
+    return {
+      results: response.taxons,
+      more: response.current_page * response.per_page < response.total_count,
+    }
+  }
+
+  /**
+   * result which is visible if a taxon was selected
+   * @param {object} taxon
+   * @returns {string}
+   * @private
+   */
+  _renderResult(taxon) {
+    return taxon.text || taxon.pretty_name
+  }
+
+  /**
+   * html template for each list entry
+   * @param {object} taxon
+   * @param {string} term
+   * @returns {string}
+   * @private
+   */
+  _renderListEntry(taxon, term) {
+    return this._hightlightTerm(taxon.pretty_name, term)
+  }
+}
+
+customElements.define("alchemy-taxon-select", TaxonSelect)

data/app/javascript/alchemy_solidus/components/variant_select.js

@@ -0,0 +1,79 @@
+import { RemoteSelect } from "alchemy_admin/components/remote_select"
+import ajaxConfig from "alchemy_solidus/components/ajax_config"
+
+export default class VariantSelect extends RemoteSelect {
+  get ajaxConfig() {
+    return ajaxConfig(super.ajaxConfig, this.apiKey)
+  }
+
+  get apiKey() {
+    return this.getAttribute("api-key")
+  }
+
+  /**
+   * Search query send to server from select2
+   * @param {string} term
+   * @param {number} page
+   * @returns {object}
+   * @private
+   */
+  _searchQuery(term, page) {
+    return {
+      q: {
+        product_name_or_sku_cont: term,
+        ...JSON.parse(this.queryParams),
+      },
+      page: page,
+    }
+  }
+
+  /**
+   * Parses server response into select2 results object
+   * @param {object} response
+   * @returns {object}
+   * @private
+   */
+  _parseResponse(response) {
+    return {
+      results: response.variants,
+      more: response.current_page * response.per_page < response.total_count,
+    }
+  }
+
+  /**
+   * result which is visible if a variant was selected
+   * @param {object} variant
+   * @returns {string}
+   * @private
+   */
+  _renderResult(variant) {
+    return variant.options_text
+      ? `${variant.name} - ${variant.options_text}`
+      : variant.name
+  }
+
+  /**
+   * html template for each list entry
+   * @param {object} variant
+   * @param {string} term
+   * @returns {string}
+   * @private
+   */
+  _renderListEntry(variant, term) {
+    const name = this._hightlightTerm(variant.name, term)
+    const sku = this._hightlightTerm(variant.sku, term)
+    return `
+      <div class="variant-select-result">
+        <div>
+          <span>${name}</span>
+        </div>
+        <div>
+          <span>${variant.options_text}</span>
+          <span>${sku}</span>
+        </div>
+      </div>
+    `
+  }
+}
+
+customElements.define("alchemy-variant-select", VariantSelect)

data/app/javascript/alchemy_solidus.js

@@ -1 +1,3 @@
 import "alchemy_solidus/components/product_select"
+import "alchemy_solidus/components/taxon_select"
+import "alchemy_solidus/components/variant_select"

data/app/jobs/alchemy/solidus/base_job.rb

@@ -0,0 +1,7 @@
+module Alchemy
+  module Solidus
+    class BaseJob < ActiveJob::Base
+      retry_on ActiveRecord::Deadlocked
+    end
+  end
+end

data/app/jobs/alchemy/solidus/invalidate_elements_cache_job.rb

@@ -0,0 +1,39 @@
+module Alchemy
+  module Solidus
+    class InvalidateElementsCacheJob < BaseJob
+      queue_as :default
+
+      def perform(model_name, id)
+        now = Time.current
+
+        element_ids = model(model_name)
+          .where(related_object_id: id)
+          .joins(:element)
+          .pluck("alchemy_elements.id")
+        elements = ::Alchemy::Element.where(id: element_ids)
+
+        all_element_ids = get_all_element_ids(elements, element_ids)
+        ::Alchemy::Element.where(id: all_element_ids.uniq).update_all(updated_at: now)
+
+        page_ids = elements.joins(page_version: :page).pluck("alchemy_pages.id")
+        ::Alchemy::Page.where(id: page_ids.uniq).update_all(updated_at: now)
+      end
+
+      private
+
+      def get_all_element_ids(elements, element_ids)
+        parent_element_ids = elements.pluck(:parent_element_id).compact
+        parent_elements = ::Alchemy::Element.distinct.where(id: parent_element_ids)
+
+        if parent_elements.any?
+          element_ids += parent_element_ids
+          get_all_element_ids(parent_elements, element_ids)
+        else
+          element_ids
+        end
+      end
+
+      def model(model_name) = "Alchemy::Ingredients::#{model_name}".constantize
+    end
+  end
+end

data/app/patches/controllers/alchemy/solidus/alchemy_base_controller_patch.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Solidus
+    module AlchemyBaseControllerPatch
+      def self.prepended(base)
+        base.include Spree::Core::ControllerHelpers::Auth
+        base.include Spree::Core::ControllerHelpers::Common
+        base.include Spree::Core::ControllerHelpers::Order
+        base.include Spree::Core::ControllerHelpers::PaymentParameters
+        base.include Spree::Core::ControllerHelpers::Pricing
+        base.include Spree::Core::ControllerHelpers::Search
+        base.include Spree::Core::ControllerHelpers::Store
+        base.include Spree::Core::ControllerHelpers::StrongParameters
+      end
+
+      if defined?(::Alchemy::BaseController)
+        ::Alchemy::BaseController.prepend self
+      end
+    end
+  end
+end

data/app/patches/controllers/alchemy/solidus/application_controller_patch.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Solidus
+    module ApplicationControllerPatch
+      def spree_current_user
+        if Alchemy.user_class_name == "::Alchemy::User"
+          current_user
+        else
+          super
+        end
+      end
+
+      if defined?(::ApplicationController)
+        ::ApplicationController.prepend self
+      end
+    end
+  end
+end

data/app/patches/controllers/alchemy/solidus/spree_user_confirmations_controller_patch.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Solidus
+    module SpreeUserConfirmationsControllerPatch
+      def self.prepended(base)
+        base.include Alchemy::ControllerActions
+      end
+
+      if defined?(::Spree::UserConfirmationsController)
+        ::Spree::UserConfirmationsController.prepend self
+      end
+    end
+  end
+end

data/app/patches/controllers/alchemy/solidus/spree_user_passwords_controller_patch.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Solidus
+    module SpreeUserPasswordsControllerPatch
+      def self.prepended(base)
+        base.include Alchemy::ControllerActions
+      end
+
+      if defined?(::Spree::UserPasswordsController)
+        ::Spree::UserPasswordsController.prepend self
+      end
+    end
+  end
+end

data/app/patches/controllers/alchemy/solidus/spree_user_registrations_controller_patch.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Solidus
+    module SpreeUserRegistrationsControllerPatch
+      def self.prepended(base)
+        base.include Alchemy::ControllerActions
+      end
+
+      if defined?(::Spree::UserRegistrationsController)
+        ::Spree::UserRegistrationsController.prepend self
+      end
+    end
+  end
+end

data/app/patches/controllers/alchemy/solidus/spree_user_sessions_controller_patch.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Solidus
+    module SpreeUserSessionsControllerPatch
+      def self.prepended(base)
+        base.include Alchemy::ControllerActions
+      end
+
+      if defined?(::Spree::UserSessionsController)
+        ::Spree::UserSessionsController.prepend self
+      end
+    end
+  end
+end

data/app/patches/helpers/alchemy/solidus/alchemy_base_helper_patch.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Solidus
+    module AlchemyBaseHelperPatch
+      def self.prepended(base)
+        base.include Spree::BaseHelper
+        base.include Spree::CheckoutHelper
+        base.include Spree::ProductsHelper
+        base.include Spree::StoreHelper
+        base.include Spree::TaxonsHelper
+      end
+
+      if defined?(::Alchemy::BaseHelper)
+        ::Alchemy::BaseHelper.prepend self
+      end
+    end
+  end
+end

data/{lib/alchemy/solidus/alchemy_user_extension.rb → app/patches/models/alchemy/solidus/alchemy_user_patch.rb}

@@ -1,17 +1,21 @@
 module Alchemy
   module Solidus
-    module AlchemyUserExtension
-      def self.included(klass)
+    module AlchemyUserPatch
+      def self.prepended(klass)
         klass.include Spree::UserMethods
       end
 
       def spree_roles
         if admin?
-          ::Spree::Role.where(name: 'admin')
+          ::Spree::Role.where(name: "admin")
         else
           ::Spree::Role.none
         end
       end
+
+      if defined?(::Alchemy::User)
+        ::Alchemy::User.prepend self
+      end
     end
   end
 end

data/app/{decorators/models/alchemy/solidus/spree_product_decorator.rb → patches/models/alchemy/solidus/spree_product_patch.rb}

@@ -2,9 +2,10 @@
 
 module Alchemy
   module Solidus
-    module SpreeProductDecorator
+    module SpreeProductPatch
       def self.prepended(base)
-        base.include Alchemy::Solidus::TouchAlchemyIngredients
+        # Solidus runs touch callbacks on product after_save
+        base.after_touch :touch_alchemy_ingredients
         base.has_many :alchemy_ingredients, class_name: "Alchemy::Ingredients::SpreeProduct", as: :related_object, dependent: :nullify
       end
 
@@ -23,6 +24,12 @@ module Alchemy
         taxons.each(&:touch)
       end
 
+      # Touch all elements that have this product assigned to one of its ingredients.
+      # This cascades to all parent elements and pages as well.
+      def touch_alchemy_ingredients
+        InvalidateElementsCacheJob.perform_later("SpreeProduct", id)
+      end
+
       ::Spree::Product.prepend self
     end
   end