solidus_admin 0.4.0 → 0.5.0

data/app/controllers/solidus_admin/stores_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module SolidusAdmin
-  class StoresController < SolidusAdmin::BaseController
+  class StoresController < SolidusAdmin::ResourcesController
     include SolidusAdmin::ControllerHelpers::Search
 
     def index
@@ -10,26 +10,60 @@ module SolidusAdmin
         param: :q
       )
 
-      set_page_and_extract_portion_from(stores)
+      @page = paginate(stores)
 
       respond_to do |format|
-        format.html { render component('stores/index').new(page: @page) }
+        format.html { render component("stores/index").new(page: @page) }
       end
     end
 
     def destroy
-      @stores = Spree::Store.where(id: params[:id])
+      @resource = resource_class.where(id: params[:id])
 
-      Spree::Store.transaction { @stores.destroy_all }
+      failed = @resource.destroy_all.reject(&:destroyed?)
+      if failed.none?
+        flash[:notice] = t(".success")
+      else
+        failure_summary = failed.map { |record|
+          t ".error.description",
+            name: record.name,
+            reason: record.errors.full_messages.join(", ")
+        }.join("<br/>")
 
-      flash[:notice] = t('.success')
-      redirect_back_or_to stores_path, status: :see_other
+        flash[:alert] = {
+          danger: {title: t(".error.title"), message: failure_summary}
+        }
+      end
+
+      redirect_to after_destroy_path, status: :see_other
     end
 
     private
 
-    def store_params
-      params.require(:store).permit(:store_id, permitted_store_attributes)
+    def resource_class = Spree::Store
+
+    def resources_collection = Spree::Store
+
+    def permitted_resource_params
+      permitted = [
+        :name,
+        :url,
+        :code,
+        :meta_description,
+        :meta_keywords,
+        :seo_title,
+        :mail_from_address,
+        :default_currency,
+        :cart_tax_country_iso,
+        {available_locales: []}
+      ]
+      # This check can be removed once we drop support for Solidus 4.7 and earlier.
+      permitted << {address_attributes: Spree::PermittedAttributes.address_attributes} if Spree::Store.reflect_on_association(:address)
+
+      params.require(:store).permit(*permitted).tap do |store_params|
+        without_address_parameter = store_params[:address_attributes]&.except(:country_id, :state_id, :reverse_charge_status)&.compact_blank&.empty?
+        store_params.delete(:address_attributes) if without_address_parameter
+      end
     end
   end
 end

data/app/controllers/solidus_admin/tax_rates_controller.rb

@@ -1,35 +1,22 @@
 # frozen_string_literal: true
 
 module SolidusAdmin
-  class TaxRatesController < SolidusAdmin::BaseController
+  class TaxRatesController < SolidusAdmin::ResourcesController
     include SolidusAdmin::ControllerHelpers::Search
 
-    def index
-      tax_rates = apply_search_to(
-        Spree::TaxRate.order(created_at: :desc, id: :desc),
-        param: :q,
-      )
-
-      set_page_and_extract_portion_from(tax_rates)
-
-      respond_to do |format|
-        format.html { render component('tax_rates/index').new(page: @page) }
-      end
-    end
-
-    def destroy
-      @tax_rates = Spree::TaxRate.where(id: params[:id])
+    private
 
-      Spree::TaxRate.transaction { @tax_rates.destroy_all }
+    def resource_class = Spree::TaxRate
 
-      flash[:notice] = t('.success')
-      redirect_back_or_to tax_rates_path, status: :see_other
+    def resources_collection
+      resource_class.includes(:zone, :tax_categories, :calculator)
     end
 
-    private
+    def resources_sorting_options = {created_at: :desc, id: :desc}
 
-    def tax_rate_params
-      params.require(:tax_rate).permit(:tax_rate_id, permitted_tax_rate_attributes)
+    def permitted_resource_params
+      params.require(:tax_rate).permit(:name, :zone_id, :show_rate_in_label, :calculator_type, :amount, :level,
+        :included_in_price, :starts_at, :expires_at, tax_category_ids: [])
     end
   end
 end

data/app/controllers/solidus_admin/taxonomies_controller.rb

@@ -3,27 +3,18 @@
 module SolidusAdmin
   class TaxonomiesController < SolidusAdmin::BaseController
     include SolidusAdmin::ControllerHelpers::Search
-
-    before_action :load_taxonomy, only: [:move]
+    include SolidusAdmin::Moveable
 
     def index
       taxonomies = apply_search_to(
         Spree::Taxonomy.all,
-        param: :q,
+        param: :q
       )
 
-      set_page_and_extract_portion_from(taxonomies)
+      @page = paginate(taxonomies)
 
       respond_to do |format|
-        format.html { render component('taxonomies/index').new(page: @page) }
-      end
-    end
-
-    def move
-      @taxonomy.insert_at(params[:position].to_i)
-
-      respond_to do |format|
-        format.js { head :no_content }
+        format.html { render component("taxonomies/index").new(page: @page) }
       end
     end
 
@@ -32,15 +23,8 @@ module SolidusAdmin
 
       Spree::Taxonomy.transaction { @taxonomies.destroy_all }
 
-      flash[:notice] = t('.success')
+      flash[:notice] = t(".success")
       redirect_back_or_to taxonomies_path, status: :see_other
     end
-
-    private
-
-    def load_taxonomy
-      @taxonomy = Spree::Taxonomy.find(params[:id])
-      authorize! action_name, @taxonomy
-    end
   end
 end

data/app/controllers/solidus_admin/users_controller.rb

@@ -8,28 +8,28 @@ module SolidusAdmin
     before_action :set_user, only: [:edit, :addresses, :update_addresses, :orders, :items]
 
     search_scope(:all, default: true)
-    search_scope(:customers) { _1.left_outer_joins(:role_users).where(role_users: { id: nil }) }
+    search_scope(:customers) { _1.left_outer_joins(:role_users).where(role_users: {id: nil}) }
     search_scope(:admin) { _1.joins(:role_users).distinct }
     search_scope(:with_orders) { _1.joins(:orders).distinct }
-    search_scope(:without_orders) { _1.left_outer_joins(:orders).where(orders: { id: nil }) }
+    search_scope(:without_orders) { _1.left_outer_joins(:orders).where(orders: {id: nil}) }
 
     def index
       users = apply_search_to(
         Spree.user_class.order(created_at: :desc, id: :desc),
-        param: :q,
+        param: :q
       )
 
-      set_page_and_extract_portion_from(users)
+      @page = paginate(users)
 
       respond_to do |format|
-        format.html { render component('users/index').new(page: @page) }
+        format.html { render component("users/index").new(page: @page) }
       end
     end
 
     def addresses
       respond_to do |format|
         format.turbo_stream { render turbo_stream: '<turbo-stream action="refresh" />' }
-        format.html { render component('users/addresses').new(user: @user) }
+        format.html { render component("users/addresses").new(user: @user) }
       end
     end
 
@@ -37,15 +37,15 @@ module SolidusAdmin
       set_address_from_params
 
       if @address.valid? && @user.update(user_params)
-        flash[:success] = t(".#{@type}.success")
+        flash[:notice] = t(".#{@type}.success")
 
         respond_to do |format|
           format.turbo_stream { render turbo_stream: '<turbo-stream action="refresh" />' }
-          format.html { render component('users/addresses').new(user: @user) }
+          format.html { render component("users/addresses").new(user: @user) }
         end
       else
         respond_to do |format|
-          format.html { render component('users/addresses').new(user: @user, address: @address, type: @type), status: :unprocessable_entity }
+          format.html { render component("users/addresses").new(user: @user, address: @address, type: @type), status: :unprocessable_entity }
         end
       end
     end
@@ -54,7 +54,7 @@ module SolidusAdmin
       set_orders
 
       respond_to do |format|
-        format.html { render component('users/orders').new(user: @user, orders: @orders) }
+        format.html { render component("users/orders").new(user: @user, orders: @orders) }
       end
     end
 
@@ -62,13 +62,13 @@ module SolidusAdmin
       set_items
 
       respond_to do |format|
-        format.html { render component('users/items').new(user: @user, items: @items) }
+        format.html { render component("users/items").new(user: @user, items: @items) }
       end
     end
 
     def edit
       respond_to do |format|
-        format.html { render component('users/edit').new(user: @user) }
+        format.html { render component("users/edit").new(user: @user) }
       end
     end
 
@@ -77,7 +77,7 @@ module SolidusAdmin
 
       Spree.user_class.transaction { @users.destroy_all }
 
-      flash[:notice] = t('.success')
+      flash[:notice] = t(".success")
       redirect_back_or_to users_path, status: :see_other
     end
 
@@ -112,13 +112,13 @@ module SolidusAdmin
     def set_orders
       params[:q] ||= {}
       @search = Spree::Order.reverse_chronological.ransack(params[:q].merge(user_id_eq: @user.id))
-      @orders = @search.result.page(params[:page]).per(Spree::Config[:admin_products_per_page])
+      @orders = @search.result.page(params[:page]).per(Spree::Config.admin_products_per_page)
     end
 
     def set_items
       params[:q] ||= {}
-      @search = Spree::Order.reverse_chronological.includes(line_items: { variant: [:product, { option_values: :option_type }] }).ransack(params[:q].merge(user_id_eq: @user.id))
-      @orders = @search.result.page(params[:page]).per(Spree::Config[:admin_products_per_page])
+      @search = Spree::Order.reverse_chronological.includes(line_items: {variant: [:product, {option_values: :option_type}]}).ransack(params[:q].merge(user_id_eq: @user.id))
+      @orders = @search.result.page(params[:page]).per(Spree::Config.admin_products_per_page)
       @items = @orders&.map(&:line_items)&.flatten
     end
 

data/app/controllers/solidus_admin/zones_controller.rb

@@ -1,35 +1,15 @@
 # frozen_string_literal: true
 
 module SolidusAdmin
-  class ZonesController < SolidusAdmin::BaseController
-    include SolidusAdmin::ControllerHelpers::Search
-
-    def index
-      zones = apply_search_to(
-        Spree::Zone.order(id: :desc),
-        param: :q
-      )
-
-      set_page_and_extract_portion_from(zones)
-
-      respond_to do |format|
-        format.html { render component('zones/index').new(page: @page) }
-      end
-    end
-
-    def destroy
-      @zones = Spree::Zone.where(id: params[:id])
-
-      Spree::Zone.transaction { @zones.destroy_all }
+  class ZonesController < SolidusAdmin::ResourcesController
+    private
 
-      flash[:notice] = t('.success')
-      redirect_back_or_to zones_path, status: :see_other
-    end
+    def resource_class = Spree::Zone
 
-    private
+    def resources_collection = Spree::Zone.includes(zone_members: :zoneable)
 
-    def zone_params
-      params.require(:zone).permit(:zone_id, permitted_zone_attributes)
+    def permitted_resource_params
+      params.require(:zone).permit(:name, :description, state_ids: [], country_ids: [])
     end
   end
 end

data/app/helpers/solidus_admin/flash_helper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Reserve :alert for messages that should go in UI alert component. Everything else will be shown in UI toast.
+module SolidusAdmin
+  module FlashHelper
+    def toasts
+      flash.to_hash.with_indifferent_access.except(:alert)
+    end
+
+    def alerts
+      flash.to_hash.with_indifferent_access.fetch(:alert, {})
+    end
+  end
+end

data/app/helpers/solidus_admin/last_login_helper.rb

@@ -3,10 +3,10 @@
 module SolidusAdmin
   module LastLoginHelper
     def last_login(user)
-      return t('solidus_admin.users.last_login.never') if user.try(:last_sign_in_at).blank?
+      return t("solidus_admin.users.last_login.never") if user.try(:last_sign_in_at).blank?
 
       t(
-        'solidus_admin.users.last_login.login_time_ago',
+        "solidus_admin.users.last_login.login_time_ago",
         # @note The second `.try` is here for the specs and for setups that use a
         # custom User class which may not have this attribute.
         last_login_time: time_ago_in_words(user.try(:last_sign_in_at))

data/app/helpers/solidus_admin/permission_sets_helper.rb

@@ -18,13 +18,13 @@ module SolidusAdmin
         case permission.privilege
         when "display"
           grouped_permissions[group_key] ||= []
-          grouped_permissions[group_key] << { label: view_label, id: permission.id }
+          grouped_permissions[group_key] << {label: view_label, id: permission.id}
         when "management"
           grouped_permissions[group_key] ||= []
-          grouped_permissions[group_key] << { label: edit_label, id: permission.id }
+          grouped_permissions[group_key] << {label: edit_label, id: permission.id}
         else
           grouped_permissions[:other] ||= []
-          grouped_permissions[:other] << { label: permission.name, id: permission.id }
+          grouped_permissions[:other] << {label: permission.name, id: permission.id}
         end
       end
     end

data/app/helpers/solidus_admin/solidus_form_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  module SolidusFormHelper
+    def solidus_form_for(*args, **kwargs, &block)
+      form_for(*args, **kwargs, builder: SolidusAdmin::FormBuilder, &block)
+    end
+  end
+end

data/app/helpers/solidus_admin/stimulus_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Simple shorthands and helpers for stimulus data attributes to avoid writing clumsy interpolations with `stimulus_id`
+#  Before: "data-#{stimulus_id}-target": "wrapper"
+#  After: stimulus_target("wrapper")
+
+module SolidusAdmin
+  module StimulusHelper
+    def stimulus_controller
+      {"data-controller": stimulus_id}
+    end
+
+    def stimulus_action(action, on: nil)
+      action_construct = []
+      action_construct << "#{on}->" if on.present?
+      action_construct << "#{stimulus_id}##{action}"
+
+      {"data-action": action_construct.join}
+    end
+
+    def stimulus_target(target)
+      {"data-#{stimulus_id}-target": target}
+    end
+
+    def stimulus_value(name:, value:)
+      {"data-#{stimulus_id}-#{name}-value": value}
+    end
+  end
+end

data/app/helpers/solidus_admin/void_elements_helper.rb

@@ -3,7 +3,7 @@
 module SolidusAdmin
   module VoidElementsHelper
     # https://github.com/rails/rails/blob/194d697036c61af0caa66de5659721ded2478ce9/actionview/lib/action_view/helpers/tag_helper.rb#L84
-    HTML_VOID_ELEMENTS = %i(area base br col embed hr img input keygen link meta source track wbr)
+    HTML_VOID_ELEMENTS = %i[area base br col embed hr img input keygen link meta source track wbr]
 
     # @param element [Symbol]
     def void_element?(element)

data/app/javascript/solidus_admin/application.js

@@ -1,2 +1,11 @@
-import "@hotwired/turbo-rails"
+import { Turbo } from "@hotwired/turbo-rails"
+import "vendor/custom_elements"
 import "solidus_admin/controllers"
+import { openConfirmModal } from "solidus_admin/confirm_modal"
+import "solidus_admin/web_components/solidus_select"
+
+if (Turbo.config) {
+  Turbo.config.forms.confirm = openConfirmModal
+} else {
+  window.Turbo.setConfirmMethod(openConfirmModal)
+}

data/app/javascript/solidus_admin/confirm_modal.js

@@ -0,0 +1,24 @@
+import { application } from "solidus_admin/controllers/application"
+
+/*
+ * Opens a confirmation modal with the given message and options.
+ * This is used as the Turbo confirm modal replacement. It returns a
+ * Promise that resolves to true if the user confirms, or false if
+ * the user cancels.
+ *
+ * @param {string} message - The message to display in the confirmation modal.
+ * @param {HTMLFormElement} formElement - Form element that triggered the
+ *   confirmation.
+ * @param {HTMLElement} submitter - The element that triggered the form
+ *   submission.
+ * @returns {Promise<boolean>} - A promise that resolves to true if the user
+ *   confirms, or false if the user cancels.
+ */
+export function openConfirmModal(message, formElement, submitter) {
+  const element = document.getElementById("confirm")
+  const controller = application.getControllerForElementAndIdentifier(element, "layout--confirm")
+  const details = submitter?.dataset.confirmDetails ?? formElement?.dataset.confirmDetails ?? ""
+  const buttonText = submitter?.dataset.confirmButton ?? formElement?.dataset.confirmButton
+
+  return controller.open(message, { details, buttonText })
+}

data/app/javascript/solidus_admin/controllers/custom_validity_controller.js

@@ -0,0 +1,12 @@
+import { Controller } from "@hotwired/stimulus"
+import { setValidity } from "solidus_admin/utils";
+
+export default class extends Controller {
+  static values = {
+    errorMessage: String,
+  }
+
+  connect() {
+    setValidity(this.element, this.errorMessageValue);
+  }
+}

data/app/javascript/solidus_admin/controllers/sortable_controller.js

@@ -4,9 +4,11 @@ import { patch } from '@rails/request.js'
 
 export default class extends Controller {
   static values = {
-    param: { type: String, default: 'postion' },
+    param: { type: String, default: 'position' },
     handle: { type: String, default: null },
     animation: { type: Number, default: 150 },
+    page: { type: Number },
+    perPage: { type: Number },
   }
 
   connect() {
@@ -21,7 +23,12 @@ export default class extends Controller {
     if (!item.dataset.sortableUrl) return
 
     const data = new FormData()
-    data.append(this.paramValue, newIndex + 1)
+    let newPosition = newIndex + 1;
+    if (this.pageValue && this.perPageValue) {
+      const offset = (this.pageValue - 1) * this.perPageValue;
+      newPosition += offset;
+    }
+    data.append(this.paramValue, newPosition)
 
     return await patch(item.dataset.sortableUrl, { body: data, responseKind: "js" })
   }

data/app/javascript/solidus_admin/tom-select/plugins/patch_scroll.js

@@ -0,0 +1,19 @@
+const patch = function(fnName) {
+  const originalFn = this[fnName];
+  this.hook("instead", fnName, function() {
+    const originalScrollToOption = this.scrollToOption;
+
+    this.scrollToOption = () => {};
+    originalFn.apply(this, arguments);
+    this.scrollToOption = originalScrollToOption;
+  });
+}
+
+// https://github.com/orchidjs/tom-select/issues/556
+// https://github.com/orchidjs/tom-select/issues/867
+export default function() {
+  this.on("initialize", function() {
+    patch.call(this, "onOptionSelect");
+    patch.call(this, "loadCallback");
+  })
+}

data/app/javascript/solidus_admin/tom-select/plugins/remote_with_pagination.js

@@ -0,0 +1,67 @@
+import { parseLinkHeader } from "solidus_admin/utils";
+
+// Fetch all options from remote source and setup pagination if needed
+const loadOptions = async function(query, callback) {
+  const { options, next } = await fetchOptions.call(this, query);
+  if (next) {
+    this.setNextUrl(query, next);
+  }
+
+  callback(options);
+}
+
+// Fetch options from remote source. If options data is nested in json response, specify path to it with "jsonPath"
+// E.g. https://whatcms.org/API/List data is deep nested in json response: `{ result: { list: [...] } }`, so
+//  in order to access it, pass config options to this plugin as follows:
+//  {
+//    src: "https://whatcms.org/API/List",
+//    jsonPath: "result.list"
+//  }
+const fetchOptions = async function(query) {
+  const dataPath = this.settings.jsonPath;
+  const response = await fetch(buildUrl.call(this, query), { headers: { "Accept": "application/json" } });
+  if (!response.ok) {
+    return { options: [] };
+  }
+
+  const next = parseLinkHeader(response.headers.get("Link")).next;
+  const json = await response.json();
+
+  let options;
+  if (!dataPath) {
+    options = json;
+  } else {
+    options = dataPath.split('.').reduce((acc, key) => acc && acc[key], json);
+  }
+
+  return { options, next };
+}
+
+const buildUrl = function(query) {
+  const url = new URL(this.getUrl(query));
+  const queryParam = this.settings.queryParam;
+  if (!query || !queryParam) return url.toString();
+
+  url.searchParams.set(queryParam, query);
+  return url.toString();
+}
+
+export default function(config) {
+  this.settings.firstUrl = () => config.src;
+  this.settings.load = loadOptions.bind(this);
+  this.settings.preload = config.preload;
+  this.settings.searchField = [this.settings.labelField];
+  this.settings.jsonPath = config.jsonPath;
+  this.settings.queryParam = config.queryParam;
+  this.settings.render = Object.assign(this.settings.render, {
+    loading: function() {
+      return `<div class='loading'>${config.loadingMessage}</div>`;
+    },
+    loading_more: function() {
+      return `<div class='loading-more'>${config.loadingMoreMessage}</div>`;
+    },
+    no_more_results: function() {},
+  });
+
+  this.require("virtual_scroll");
+}

data/app/javascript/solidus_admin/tom-select/plugins/stash_on_search.js

@@ -0,0 +1,68 @@
+// Substitute default TomSelect functionality for single selects, where typing in the select field while there is
+//  an option selected shows both selected option and the search term.
+// Instead, hide the selected option when typing and bring it back when leaving the field.
+class Stash {
+  #content = {};
+
+  put(value, data) {
+    this.#content["value"] = value;
+    this.#content["data"] = data;
+  }
+
+  pop() {
+    const { value, data } = this.#content;
+    this.clear();
+    return { value, data };
+  }
+
+  clear() {
+    this.#content = {};
+  }
+
+  get isEmpty() {
+    return Object.keys(this.#content).length === 0;
+  }
+}
+
+export default function() {
+  if (this.settings.mode === 'multi') return;
+
+  this.stash = new Stash();
+
+  this.stashSelected = function() {
+    if (!this.stash.isEmpty) return;
+    if (!this.items.length) return;
+
+    const currentValue = this.items[0];
+    this.stash.put(currentValue, this.options[currentValue]);
+    this.clear(true);
+  };
+
+  this.unstashSelected = function() {
+    if (this.stash.isEmpty) return;
+
+    const { value, data } = this.stash.pop();
+    // In case this is a select with remote source, options are refreshed on each search, so we need to put the option
+    //  back in the list for TomSelect to pick it as a selected item.
+    // If the option is already in the list, it will be ignored.
+    this.addOption(data);
+    this.setValue(value, true);
+  };
+
+  // save current selected option in case user won't select anything
+  this.on("type", function() {
+    this.stashSelected();
+  });
+
+  // new option has been selected, no need to hold on to previous option
+  this.on("item_add", function() {
+    this.stash.clear();
+  });
+
+  // if nothing has been selected restore previous option
+  this.on("blur", function() {
+    if (this.items.length) return;
+
+    this.unstashSelected();
+  });
+}

data/app/javascript/solidus_admin/tom-select/tom-select.js

@@ -0,0 +1,11 @@
+import TomSelect from "tom-select";
+
+import patchScroll from "./plugins/patch_scroll.js";
+import stashOnSearch from "./plugins/stash_on_search.js";
+import remoteWithPagination from "./plugins/remote_with_pagination.js";
+
+TomSelect.define("patch_scroll", patchScroll);
+TomSelect.define("stash_on_search", stashOnSearch);
+TomSelect.define("remote_with_pagination", remoteWithPagination);
+
+export default TomSelect;