Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.
Ruby b2b-commercee-commerceecommerceecommerce-apiecommerce-frameworkecommerce-platformheadlessheadless-commerceheadless-ecommercemarketplacemulti-tenantmulti-vendormulti-vendor-ecommerceopen-sourcespree-commerce
Admin Records List component (initial pass)
Damian Legawiec3a600db8abf6
diff --git a/admin/app/controllers/spree/admin/record_list_columns_controller.rb b/admin/app/controllers/spree/admin/record_list_columns_controller.rbnew file mode 100644index 0000000000..37fa106b44--- /dev/null+++ b/admin/app/controllers/spree/admin/record_list_columns_controller.rb@@ -0,0 +1,28 @@+module Spree+ module Admin+ class RecordListColumnsController < Spree::Admin::BaseController+ # POST /admin/record_list_columns+ # Updates the selected columns for a record list in the session+ def update+ list_key = params[:list_key]+ columns = params[:columns]++ if list_key.present?+ if columns.present?+ # Filter to only include valid column keys+ column_keys = Array(columns).map(&:to_sym)+ session["record_list_columns_#{list_key}"] = column_keys.join(',')+ else+ # Clear selection to use defaults+ session.delete("record_list_columns_#{list_key}")+ end+ end++ respond_to do |format|+ format.html { redirect_back fallback_location: spree.admin_path }+ format.turbo_stream { redirect_back fallback_location: spree.admin_path }+ end+ end+ end+ end+enddiff --git a/admin/app/controllers/spree/admin/tags_controller.rb b/admin/app/controllers/spree/admin/tags_controller.rbnew file mode 100644index 0000000000..00807ce34e--- /dev/null+++ b/admin/app/controllers/spree/admin/tags_controller.rb@@ -0,0 +1,32 @@+module Spree+ module Admin+ class TagsController < Spree::Admin::BaseController+ def select_options+ tags = tags_scope++ if params[:q].present?+ tags = tags.where('LOWER(name) LIKE ?', "%#{params[:q].downcase}%")+ end++ render json: tags.limit(100).pluck(:id, :name).map { |id, name| { id: id, name: name } }+ end++ private++ def tags_scope+ context = params[:context].presence || 'tags'+ taggable_type = params[:taggable_type].presence++ scope = ActsAsTaggableOn::Tag.for_context(context)++ if taggable_type.present?+ scope = scope.joins(:taggings)+ .where(ActsAsTaggableOn.taggings_table => { taggable_type: taggable_type })+ .distinct+ end++ scope.order(:name)+ end+ end+ end+enddiff --git a/admin/app/helpers/spree/admin/record_list_helper.rb b/admin/app/helpers/spree/admin/record_list_helper.rbnew file mode 100644index 0000000000..57cfc21e8b--- /dev/null+++ b/admin/app/helpers/spree/admin/record_list_helper.rb@@ -0,0 +1,294 @@+module Spree+ module Admin+ module RecordListHelper+ # Main helper to render a record list+ # @param collection [ActiveRecord::Relation] the collection to render+ # @param list_key [Symbol] the record list registry key (e.g., :products)+ # @param options [Hash] additional options+ # @option options [Boolean] :bulk_operations enable bulk operations+ # @option options [Boolean] :sortable enable drag-and-drop sorting+ # @option options [String] :frame_name custom turbo frame name+ # @return [String] rendered HTML+ def render_record_list(collection, list_key, **options)+ record_list = Spree.admin.record_lists.get(list_key)+ selected_columns = session_selected_columns(list_key)++ render 'spree/admin/record_lists/record_list',+ collection: collection,+ record_list: record_list,+ list_key: list_key,+ selected_columns: selected_columns,+ **options+ end++ # Get selected column keys from session+ # @param list_key [Symbol] record list key+ # @return [Array<Symbol>, nil]+ def session_selected_columns(list_key)+ keys = session["record_list_columns_#{list_key}"]+ return nil if keys.blank?++ keys.split(',').map(&:to_sym)+ end++ # Save selected columns to session+ # @param list_key [Symbol] record list key+ # @param column_keys [Array<Symbol>] selected column keys+ def save_selected_columns(list_key, column_keys)+ session["record_list_columns_#{list_key}"] = column_keys.join(',')+ end++ # Render a single column value based on its type+ # @param record [Object] the record+ # @param column [Spree::Admin::RecordList::Column] the column definition+ # @param record_list [Spree::Admin::RecordList] the record list+ # @return [String] rendered HTML+ def render_column_value(record, column, record_list)+ value = column.resolve_value(record, self)++ case column.type+ when :currency+ render_currency_column(value, column)+ when :date+ render_date_column(value, column)+ when :datetime+ render_datetime_column(value, column)+ when :status+ render_status_column(value, column)+ when :boolean+ render_boolean_column(value, column)+ when :link+ render_link_column(record, value, column)+ when :image+ render_image_column(record, value, column)+ when :custom+ render partial: column.partial, locals: { record: record, column: column, value: value }+ when :association+ render_association_column(value, column)+ else+ render_string_column(value, column)+ end+ end++ # Render currency column+ # @param value [Object] the value+ # @param column [Spree::Admin::RecordList::Column] column definition+ # @return [String]+ def render_currency_column(value, column)+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?++ if value.respond_to?(:display_amount)+ value.display_amount+ else+ Spree::Money.new(value, currency: current_currency).to_html+ end+ end++ # Render date column+ # @param value [Object] the value+ # @param column [Spree::Admin::RecordList::Column] column definition+ # @return [String]+ def render_date_column(value, column)+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?++ if column.format.present? && respond_to?(column.format)+ send(column.format, value)+ else+ l(value.to_date, format: :short)+ end+ end++ # Render datetime column+ # @param value [Object] the value+ # @param column [Spree::Admin::RecordList::Column] column definition+ # @return [String]+ def render_datetime_column(value, column)+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?++ if column.format.present? && respond_to?(column.format)+ send(column.format, value)+ else+ local_time_ago(value)+ end+ end++ # Render status column as badge+ # @param value [Object] the value+ # @param column [Spree::Admin::RecordList::Column] column definition+ # @return [String]+ def render_status_column(value, column)+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?++ css_class = case value.to_s+ when 'active', 'complete', 'completed', 'paid', 'shipped', 'available'+ 'badge-active'+ when 'draft', 'pending', 'processing', 'ready'+ 'badge-warning'+ when 'archived', 'canceled', 'cancelled', 'failed', 'void', 'inactive'+ 'badge-inactive'+ else+ 'badge-secondary'+ end++ content_tag(:span, Spree.t(value, scope: column.key, default: value.to_s.humanize), class: "badge #{css_class}")+ end++ # Render boolean column+ # @param value [Object] the value+ # @param column [Spree::Admin::RecordList::Column] column definition+ # @return [String]+ def render_boolean_column(value, column)+ active_badge(value)+ end++ # Render link column+ # @param record [Object] the record+ # @param value [Object] the value+ # @param column [Spree::Admin::RecordList::Column] column definition+ # @return [String]+ def render_link_column(record, value, column)+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?++ h(value.to_s.truncate(100))+ end++ # Render image column+ # @param record [Object] the record+ # @param value [Object] the value+ # @param column [Spree::Admin::RecordList::Column] column definition+ # @return [String]+ def render_image_column(record, value, column)+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?++ if value.respond_to?(:attached?) && value.attached?+ image_tag url_for(value.variant(resize_to_limit: [50, 50])), class: 'rounded', loading: 'lazy'+ elsif value.is_a?(String) && value.present?+ image_tag value, class: 'rounded', style: 'max-width: 50px; max-height: 50px;', loading: 'lazy'+ else+ content_tag(:span, '-', class: 'text-gray-400')+ end+ end++ # Render string column+ # @param value [Object] the value+ # @param column [Spree::Admin::RecordList::Column] column definition+ # @return [String]+ def render_string_column(value, column)+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?++ if column.format.present? && respond_to?(column.format)+ send(column.format, value)+ else+ h(value.to_s.truncate(100))+ end+ end++ # Render association column (e.g., taxons, tags)+ # @param value [Object] the value (expected to be a string from method lambda)+ # @param column [Spree::Admin::RecordList::Column] column definition+ # @return [String]+ def render_association_column(value, column)+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?++ h(value.to_s.truncate(100))+ end++ # Render sort dropdown for sortable columns+ # @param record_list [Spree::Admin::RecordList] the record list+ # @param current_sort [String, nil] current sort value (e.g., "name asc")+ # @return [String]+ def record_list_sort_dropdown(record_list, current_sort)+ sortable = record_list.sortable_columns+ return '' if sortable.empty?++ current_label = find_sort_label(sortable, current_sort)++ dropdown(portal: false) do+ toggle = dropdown_toggle(class: 'btn-light btn-sm flex items-center gap-1') do+ safe_join([+ icon('arrows-sort', class: 'w-4 h-4'),+ content_tag(:span, current_label),+ icon('chevron-down', class: 'w-3 h-3')+ ])+ end++ menu = dropdown_menu(class: 'min-w-[200px]') do+ items = sortable.flat_map do |column|+ [+ sort_dropdown_item(column, 'asc', current_sort),+ sort_dropdown_item(column, 'desc', current_sort)+ ]+ end+ safe_join(items)+ end++ safe_join([toggle, menu])+ end+ end++ # Get column header CSS class+ # @param column [Spree::Admin::RecordList::Column] column definition+ # @return [String]+ def column_header_class(column)+ classes = []+ classes << "text-#{column.align}" if column.align != :left+ classes << "w-#{column.width}" if column.width.present?+ classes.join(' ')+ end++ # Get column cell CSS class+ # @param column [Spree::Admin::RecordList::Column] column definition+ # @return [String]+ def column_cell_class(column)+ classes = []+ classes << "text-#{column.align}" if column.align != :left+ classes.join(' ')+ end++ # Build query builder fields JSON for Stimulus controller+ # @param record_list [Spree::Admin::RecordList] the record list+ # @return [String] JSON string+ def query_builder_fields_json(record_list)+ query_builder = Spree::Admin::RecordList::QueryBuilder.new(record_list)+ query_builder.available_fields.to_json+ end++ # Build available operators JSON for Stimulus controller+ # @return [String] JSON string+ def query_builder_operators_json+ Spree::Admin::RecordList::Filter.operators_for_select.to_json+ end++ private++ def find_sort_label(sortable, current_sort)+ return Spree.t('admin.record_lists.sort_by') if current_sort.blank?++ field, direction = current_sort.split(' ')+ column = sortable.find { |c| c.ransack_attribute == field }++ if column+ dir_label = direction == 'asc' ? 'ASC' : 'DESC'+ "#{column.resolve_label} (#{dir_label})"+ else+ Spree.t('admin.record_lists.sort_by')+ end+ end++ def sort_dropdown_item(column, direction, current_sort)+ sort_value = "#{column.ransack_attribute} #{direction}"+ is_active = current_sort == sort_value+ dir_label = direction == 'asc' ? 'ASC' : 'DESC'+ label = "#{column.resolve_label} (#{dir_label})"++ # Convert params[:q] to a regular hash to avoid unpermitted parameters error+ current_q = params[:q].respond_to?(:to_unsafe_h) ? params[:q].to_unsafe_h : (params[:q] || {})++ link_to label,+ url_for(q: current_q.merge(s: sort_value)),+ class: "dropdown-item #{'active' if is_active}",+ data: { turbo_action: 'advance' }+ end+ end+ end+enddiff --git a/admin/app/javascript/spree/admin/application.js b/admin/app/javascript/spree/admin/application.jsindex c3d4e6ede3..e34a30b349 100644--- a/admin/app/javascript/spree/admin/application.js+++ b/admin/app/javascript/spree/admin/application.js@@ -52,6 +52,7 @@ import CalendarRangeController from 'spree/admin/controllers/calendar_range_contimport Clipboard from 'spree/admin/controllers/clipboard_controller'import CodeMirrorController from 'spree/admin/controllers/codemirror_controller'import ColorPaletteController from 'spree/admin/controllers/color_palette_controller'+import ColumnSelectorController from 'spree/admin/controllers/column_selector_controller'import ColorPickerController from 'spree/admin/controllers/color_picker_controller'import DropdownController from 'spree/admin/controllers/dropdown_controller'import FiltersController from 'spree/admin/controllers/filters_controller'@@ -65,7 +66,9 @@ import OrderBillingAddressController from 'spree/admin/controllers/order_billingimport PageBuilderController from 'spree/admin/controllers/page_builder_controller'import PasswordToggle from 'spree/admin/controllers/password_toggle_controller'import ProductFormController from 'spree/admin/controllers/product_form_controller'+import QueryBuilderController from 'spree/admin/controllers/query_builder_controller'import RangeInputController from 'spree/admin/controllers/range_input_controller'+import RecordListController from 'spree/admin/controllers/record_list_controller'import ReturnItemsController from 'spree/admin/controllers/return_items_controller'import ReplaceController from 'spree/admin/controllers/replace_controller'import RowLinkController from 'spree/admin/controllers/row_link_controller'@@ -110,6 +113,7 @@ application.register('clipboard', Clipboard)application.register('codemirror', CodeMirrorController)application.register('color-palette', ColorPaletteController)application.register('color-picker', ColorPickerController)+application.register('column-selector', ColumnSelectorController)application.register('dialog', Dialog)application.register('drawer', Dialog)application.register('disable-submit-button', DisableSubmitButtonController)@@ -130,7 +134,9 @@ application.register('page-builder', PageBuilderController)application.register('password-toggle', PasswordToggle)application.register('password-visibility', PasswordVisibility)application.register('product-form', ProductFormController)+application.register('query-builder', QueryBuilderController)application.register('range-input', RangeInputController)+application.register('record-list', RecordListController)application.register('replace', ReplaceController)application.register('return-items', ReturnItemsController)application.register('reveal', Reveal)diff --git a/admin/app/javascript/spree/admin/controllers/column_selector_controller.js b/admin/app/javascript/spree/admin/controllers/column_selector_controller.jsnew file mode 100644index 0000000000..9c1ea45493--- /dev/null+++ b/admin/app/javascript/spree/admin/controllers/column_selector_controller.js@@ -0,0 +1,35 @@+import { Controller } from "@hotwired/stimulus"++export default class extends Controller {+ static targets = ["checkbox"]++ connect() {+ // Controller is ready+ }++ reset(event) {+ event.preventDefault()++ // Reset all checkboxes to their default state+ this.checkboxTargets.forEach(checkbox => {+ const isDefault = checkbox.dataset.default === "true"+ checkbox.checked = isDefault+ })+ }++ selectAll(event) {+ event.preventDefault()++ this.checkboxTargets.forEach(checkbox => {+ checkbox.checked = true+ })+ }++ deselectAll(event) {+ event.preventDefault()++ this.checkboxTargets.forEach(checkbox => {+ checkbox.checked = false+ })+ }+}diff --git a/admin/app/javascript/spree/admin/controllers/query_builder_controller.js b/admin/app/javascript/spree/admin/controllers/query_builder_controller.jsnew file mode 100644index 0000000000..5bc6ecdb42--- /dev/null+++ b/admin/app/javascript/spree/admin/controllers/query_builder_controller.js@@ -0,0 +1,563 @@+import { Controller } from "@hotwired/stimulus"++export default class extends Controller {+ static targets = [+ "container",+ "filtersContainer",+ "groupsContainer",+ "hiddenInput",+ "filterTemplate",+ "groupTemplate",+ "combinatorButton",+ "combinatorLabel",+ "form"+ ]++ static values = {+ fields: Array,+ operators: Array+ }++ connect() {+ this.rootCombinator = "and"+ this.loadState()+ }++ // Called before form submission to add ransack params+ submitForm(event) {+ const form = this.hasFormTarget ? this.formTarget : event.target.closest("form")+ if (form) {+ this.generateRansackInputs(form)+ }+ }++ loadState() {+ const stateJson = this.hiddenInputTarget.value+ if (stateJson && stateJson !== "{}") {+ try {+ const state = JSON.parse(stateJson)+ this.renderState(state)+ } catch (e) {+ console.error("Failed to parse query state:", e)+ }+ }+ }++ renderState(state) {+ // Set root combinator+ if (state.combinator) {+ this.rootCombinator = state.combinator+ this.updateCombinatorDisplay()+ }++ // Render filters+ if (state.filters && state.filters.length > 0) {+ state.filters.forEach(filter => {+ this.addFilterWithData(filter, this.filtersContainerTarget)+ })+ }++ // Render groups+ if (state.groups && state.groups.length > 0) {+ state.groups.forEach(group => {+ this.addGroupWithData(group)+ })+ }+ }++ addFilter(event) {+ event.preventDefault()+ this.addFilterWithData({}, this.filtersContainerTarget)+ this.updateHiddenInput()+ }++ addFilterToGroup(event) {+ event.preventDefault()+ const groupEl = event.target.closest("[data-group-id]")+ const filtersContainer = groupEl.querySelector("[data-group-filters-container]")+ this.addFilterWithData({}, filtersContainer)+ this.updateHiddenInput()+ }++ addFilterWithData(filterData, container) {+ const template = this.filterTemplateTarget.content.cloneNode(true)+ const row = template.querySelector("[data-filter-id]")+ row.dataset.filterId = filterData.id || this.generateId()++ // Populate field options+ const fieldSelect = row.querySelector("[data-field-select]")+ this.fieldsValue.forEach(field => {+ const option = document.createElement("option")+ option.value = field.key+ option.textContent = field.label+ if (filterData.field === field.key) {+ option.selected = true+ }+ fieldSelect.appendChild(option)+ })++ // If we have a field selected, update operators and value+ if (filterData.field) {+ const fieldConfig = this.fieldsValue.find(f => f.key === filterData.field)+ if (fieldConfig) {+ this.updateOperatorOptions(row, fieldConfig.operators, filterData.operator)+ this.updateValueInput(row, fieldConfig, filterData.value)+ }+ }++ container.appendChild(row)+ }++ addOrGroup(event) {+ event.preventDefault()+ this.addGroupWithData({ combinator: "or", filters: [], groups: [] })+ this.updateHiddenInput()+ }++ addGroupWithData(groupData) {+ const template = this.groupTemplateTarget.content.cloneNode(true)+ const group = template.querySelector("[data-group-id]")+ group.dataset.groupId = groupData.id || this.generateId()+ group.dataset.combinator = groupData.combinator || "or"++ // Update combinator label+ const label = group.querySelector("[data-group-combinator-label]")+ if (label) {+ label.textContent = (groupData.combinator || "or").toUpperCase()+ }++ // Add existing filters to the group+ if (groupData.filters && groupData.filters.length > 0) {+ const filtersContainer = group.querySelector("[data-group-filters-container]")+ groupData.filters.forEach(filter => {+ this.addFilterWithData(filter, filtersContainer)+ })+ }++ this.groupsContainerTarget.appendChild(group)+ }++ removeFilter(event) {+ event.preventDefault()+ const filterRow = event.target.closest("[data-filter-id]")+ if (filterRow) {+ filterRow.remove()+ this.updateHiddenInput()+ }+ }++ removeGroup(event) {+ event.preventDefault()+ const group = event.target.closest("[data-group-id]")+ if (group) {+ group.remove()+ this.updateHiddenInput()+ }+ }++ toggleCombinator(event) {+ event.preventDefault()+ this.rootCombinator = this.rootCombinator === "and" ? "or" : "and"+ this.updateCombinatorDisplay()+ this.updateHiddenInput()+ }++ toggleGroupCombinator(event) {+ event.preventDefault()+ const group = event.target.closest("[data-group-id]")+ const currentCombinator = group.dataset.combinator+ const newCombinator = currentCombinator === "and" ? "or" : "and"++ group.dataset.combinator = newCombinator+ const label = group.querySelector("[data-group-combinator-label]")+ if (label) {+ label.textContent = newCombinator.toUpperCase()+ }++ this.updateHiddenInput()+ }++ updateCombinatorDisplay() {+ if (this.hasCombinatorLabelTarget) {+ this.combinatorLabelTarget.textContent = this.rootCombinator.toUpperCase()+ }+ }++ onFieldChange(event) {+ const filterRow = event.target.closest("[data-filter-id]")+ const field = event.target.value+ const fieldConfig = this.fieldsValue.find(f => f.key === field)++ if (fieldConfig) {+ this.updateOperatorOptions(filterRow, fieldConfig.operators)+ this.updateValueInput(filterRow, fieldConfig)+ }++ this.updateHiddenInput()+ }++ onOperatorChange(event) {+ const filterRow = event.target.closest("[data-filter-id]")+ const operator = event.target.value+ const noValueOperators = ["null", "not_null"]++ const valueContainer = filterRow.querySelector("[data-value-container]")+ if (noValueOperators.includes(operator)) {+ valueContainer.style.display = "none"+ } else {+ valueContainer.style.display = ""+ }++ this.updateHiddenInput()+ }++ onValueChange() {+ this.updateHiddenInput()+ }++ updateOperatorOptions(filterRow, operators, selectedOperator = null) {+ const operatorSelect = filterRow.querySelector("[data-operator-select]")+ operatorSelect.innerHTML = ""++ const operatorLabels = {+ eq: "equals",+ not_eq: "does not equal",+ cont: "contains",+ not_cont: "does not contain",+ start: "starts with",+ end: "ends with",+ gt: "greater than",+ gteq: "greater than or equal",+ lt: "less than",+ lteq: "less than or equal",+ in: "is any of",+ not_in: "is none of",+ null: "is empty",+ not_null: "is not empty"+ }++ operators.forEach(op => {+ const option = document.createElement("option")+ option.value = op+ option.textContent = operatorLabels[op] || op+ if (selectedOperator === op) {+ option.selected = true+ }+ operatorSelect.appendChild(option)+ })+ }++ updateValueInput(filterRow, fieldConfig, existingValue = null) {+ const valueContainer = filterRow.querySelector("[data-value-container]")+ valueContainer.innerHTML = ""++ let input+ switch (fieldConfig.type) {+ case "date":+ input = document.createElement("input")+ input.type = "date"+ input.className = "form-input text-sm"+ break+ case "datetime":+ input = document.createElement("input")+ input.type = "datetime-local"+ input.className = "form-input text-sm"+ break+ case "number":+ case "currency":+ input = document.createElement("input")+ input.type = "number"+ input.className = "form-input text-sm"+ input.step = fieldConfig.type === "currency" ? "0.01" : "1"+ break+ case "boolean":+ input = document.createElement("select")+ input.className = "form-select text-sm"+ input.innerHTML = `+ <option value="true">Yes</option>+ <option value="false">No</option>+ `+ break+ case "status":+ input = document.createElement("select")+ input.className = "form-select text-sm"+ input.innerHTML = '<option value="">Select...</option>'+ if (fieldConfig.value_options) {+ fieldConfig.value_options.forEach(opt => {+ const option = document.createElement("option")+ option.value = opt.value || opt+ option.textContent = opt.label || opt+ input.appendChild(option)+ })+ }+ break+ case "autocomplete":+ // Create a wrapper div with select controller+ const wrapper = document.createElement("div")+ wrapper.className = "w-full"+ wrapper.dataset.controller = "select"+ wrapper.dataset.selectMultipleValue = "true"++ if (fieldConfig.search_url) {+ wrapper.dataset.selectUrlValue = fieldConfig.search_url+ // Use remote search mode so it doesn't pre-fetch and overwrite our preloaded options+ wrapper.dataset.selectRemoteSearchValue = "true"+ }++ // Use name as value field for tags (tags_name ransack attribute expects tag names)+ const useNameAsValue = fieldConfig.key && fieldConfig.key.includes("name")+ if (useNameAsValue) {+ wrapper.dataset.selectValueFieldValue = "name"+ }++ input = document.createElement("select")+ input.className = "form-select text-sm"+ input.multiple = true+ input.dataset.selectTarget = "input"+ input.dataset.valueInput = "" // Mark as value input for serialization++ // Restore existing values - we store as array of {id, name} objects+ // Use remoteSearchActiveOption which properly preloads options and selects them+ if (existingValue !== null && existingValue !== undefined && Array.isArray(existingValue) && existingValue.length > 0) {+ const preloadedOptions = existingValue.map(item => {+ if (typeof item === 'object') {+ return { id: useNameAsValue ? item.name : item.id, name: item.name }+ } else {+ return { id: item, name: item }+ }+ })+ wrapper.dataset.selectRemoteSearchActiveOptionValue = JSON.stringify(preloadedOptions)+ }++ // Set up change listener on select element directly+ input.dataset.action = "change->query-builder#onValueChange"++ wrapper.appendChild(input)+ valueContainer.appendChild(wrapper)++ return // Early return since we already appended+ default:+ input = document.createElement("input")+ input.type = "text"+ input.className = "form-input text-sm"+ input.placeholder = "Enter value..."+ }++ input.dataset.valueInput = ""+ input.dataset.action = "input->query-builder#onValueChange change->query-builder#onValueChange"++ if (existingValue !== null && existingValue !== undefined) {+ input.value = existingValue+ }++ valueContainer.appendChild(input)+ }++ clear(event) {+ event.preventDefault()+ this.filtersContainerTarget.innerHTML = ""+ this.groupsContainerTarget.innerHTML = ""+ this.rootCombinator = "and"+ this.updateCombinatorDisplay()+ this.updateHiddenInput()+ }++ updateHiddenInput() {+ const state = this.serializeState()+ this.hiddenInputTarget.value = JSON.stringify(state)+ }++ serializeState() {+ const filters = this.serializeFilters(this.filtersContainerTarget)+ const groups = this.serializeGroups()++ return {+ id: "root",+ combinator: this.rootCombinator,+ filters: filters,+ groups: groups+ }+ }++ serializeFilters(container) {+ const filters = []+ container.querySelectorAll(":scope > [data-filter-id]").forEach(row => {+ // Handle multi-select (tom-select) values+ const valueInput = row.querySelector("[data-value-input]")+ let value = null++ if (valueInput) {+ if (valueInput.multiple) {+ // Get all selected options for multi-select+ // Store as objects with id and name for autocomplete restoration+ value = Array.from(valueInput.selectedOptions).map(opt => ({+ id: opt.value,+ name: opt.textContent+ }))+ } else {+ value = valueInput.value+ }+ }++ const filter = {+ id: row.dataset.filterId,+ field: row.querySelector("[data-field-select]")?.value,+ operator: row.querySelector("[data-operator-select]")?.value,+ value: value+ }+ if (filter.field) {+ filters.push(filter)+ }+ })+ return filters+ }++ serializeGroups() {+ const groups = []+ this.groupsContainerTarget.querySelectorAll(":scope > [data-group-id]").forEach(groupEl => {+ const filtersContainer = groupEl.querySelector("[data-group-filters-container]")+ const group = {+ id: groupEl.dataset.groupId,+ combinator: groupEl.dataset.combinator || "or",+ filters: this.serializeFilters(filtersContainer),+ groups: []+ }+ groups.push(group)+ })+ return groups+ }++ generateId() {+ return Math.random().toString(36).substring(2, 10)+ }++ // Generate ransack params from filters and add as hidden inputs to form+ generateRansackInputs(form) {+ // Remove any existing ransack inputs we've added+ form.querySelectorAll("[data-ransack-input]").forEach(el => el.remove())++ const state = this.serializeState()+ const ransackParams = this.stateToRansackParams(state)++ // Add hidden inputs for each ransack param+ Object.entries(ransackParams).forEach(([key, value]) => {+ if (Array.isArray(value)) {+ // For array values (like _in predicates), add multiple inputs with same name+ value.forEach(v => {+ const input = document.createElement("input")+ input.type = "hidden"+ input.name = `q[${key}][]`+ input.value = v+ input.dataset.ransackInput = ""+ form.appendChild(input)+ })+ } else {+ const input = document.createElement("input")+ input.type = "hidden"+ input.name = `q[${key}]`+ input.value = value+ input.dataset.ransackInput = ""+ form.appendChild(input)+ }+ })+ }++ // Convert state object to ransack params object+ stateToRansackParams(state) {+ const params = {}+ const combinator = state.combinator || "and"++ // For "and" combinator, each filter becomes a separate ransack param+ // For "or" combinator, we need to use ransack's grouping (more complex)+ // For simplicity, we'll handle "and" directly and "or" with groupings++ if (combinator === "and") {+ // Simple case: all filters are ANDed together+ state.filters.forEach(filter => {+ const ransackParam = this.filterToRansackParam(filter)+ Object.assign(params, ransackParam)+ })++ // Handle groups (OR groups within AND root)+ state.groups.forEach((group, idx) => {+ const groupParams = this.groupToRansackParams(group, idx)+ Object.assign(params, groupParams)+ })+ } else {+ // OR at root level - use grouping syntax+ // ransack uses: { g: { '0' => { m: 'or', c: { '0' => {...}, '1' => {...} } } } }+ // This is complex, so for MVP we'll just OR the filters+ const groupKey = `g[0]`+ params[`${groupKey}[m]`] = "or"+ state.filters.forEach((filter, idx) => {+ const filterParams = this.filterToRansackParam(filter)+ Object.entries(filterParams).forEach(([key, value]) => {+ params[`${groupKey}[c][${idx}][${key}]`] = value+ })+ })+ }++ return params+ }++ // Convert a single filter to ransack param+ filterToRansackParam(filter) {+ if (!filter.field || !filter.operator) return {}++ const operatorMap = {+ eq: "_eq",+ not_eq: "_not_eq",+ cont: "_cont",+ not_cont: "_not_cont",+ start: "_start",+ end: "_end",+ gt: "_gt",+ gteq: "_gteq",+ lt: "_lt",+ lteq: "_lteq",+ in: "_in",+ not_in: "_not_in",+ null: "_null",+ not_null: "_not_null"+ }++ const predicate = operatorMap[filter.operator] || "_eq"+ const paramName = filter.field + predicate++ // Handle null/not_null which don't need values+ if (filter.operator === "null" || filter.operator === "not_null") {+ return { [paramName]: true }+ }++ // Extract values from autocomplete objects+ let value = filter.value+ if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'object') {+ // For autocomplete values, extract just the IDs+ value = value.map(item => item.id)+ }++ return { [paramName]: value }+ }++ // Convert a group to ransack params using grouping syntax+ groupToRansackParams(group, groupIdx) {+ const params = {}+ const groupKey = `g[${groupIdx}]`+ params[`${groupKey}[m]`] = group.combinator || "or"++ group.filters.forEach((filter, filterIdx) => {+ const filterParams = this.filterToRansackParam(filter)+ Object.entries(filterParams).forEach(([key, value]) => {+ if (Array.isArray(value)) {+ value.forEach((v, vIdx) => {+ params[`${groupKey}[c][${filterIdx}][${key}][]`] = v+ })+ } else {+ params[`${groupKey}[c][${filterIdx}][${key}]`] = value+ }+ })+ })++ return params+ }+}diff --git a/admin/app/javascript/spree/admin/controllers/record_list_controller.js b/admin/app/javascript/spree/admin/controllers/record_list_controller.jsnew file mode 100644index 0000000000..e24d44006e--- /dev/null+++ b/admin/app/javascript/spree/admin/controllers/record_list_controller.js@@ -0,0 +1,20 @@+import { Controller } from "@hotwired/stimulus"++export default class extends Controller {+ static values = {+ url: String+ }++ connect() {+ // Controller is ready+ }++ // This method can be used to handle custom list interactions+ // Currently, form submission is handled by the form's native behavior+ // with Turbo, so this is mainly a placeholder for future enhancements++ refresh() {+ // Reload the current page with Turbo+ Turbo.visit(window.location.href)+ }+}diff --git a/admin/app/javascript/spree/admin/controllers/select_controller.js b/admin/app/javascript/spree/admin/controllers/select_controller.jsindex 2aaefeed4c..fecaf1297b 100644--- a/admin/app/javascript/spree/admin/controllers/select_controller.js+++ b/admin/app/javascript/spree/admin/controllers/select_controller.js@@ -72,8 +72,14 @@ export default class extends Controller {if (this.remoteSearchActiveOptionValue) {const items = JSON.parse(this.remoteSearchActiveOptionValue)- settings.options = items- settings.items = items.map(item => item.id)+ // Tom-select uses string values internally, ensure IDs are strings for matching+ const normalizedItems = items.map(item => ({+ ...item,+ id: String(item.id),+ name: item.name+ }))+ settings.options = normalizedItems+ settings.items = normalizedItems.map(item => item[this.valueFieldValue])}}diff --git a/admin/app/models/spree/admin/record_list.rb b/admin/app/models/spree/admin/record_list.rbnew file mode 100644index 0000000000..a317250ffb--- /dev/null+++ b/admin/app/models/spree/admin/record_list.rb@@ -0,0 +1,158 @@+module Spree+ module Admin+ class RecordList+ attr_reader :columns, :context, :model_class+ attr_accessor :search_param, :search_placeholder++ def initialize(context, model_class: nil, search_param: :name_cont, search_placeholder: nil)+ @context = context+ @model_class = model_class+ @columns = {}+ @search_param = search_param+ @search_placeholder = search_placeholder+ end++ # Add a column definition+ # @param key [Symbol] unique column identifier+ # @param options [Hash] column options (label, type, sortable, filterable, default, position, etc.)+ # @return [Column] the created column+ def add(key, **options, &block)+ key = key.to_sym+ column = Column.new(key, **options)+ @columns[key] = column++ if block_given?+ builder = Builder.new(self, column)+ builder.instance_eval(&block)+ end++ sort_columns!+ column+ end++ # Remove a column+ # @param key [Symbol] column key to remove+ # @return [Column, nil] the removed column or nil+ def remove(key)+ @columns.delete(key.to_sym)+ end++ # Update an existing column+ # @param key [Symbol] column key to update+ # @param options [Hash] attributes to update+ # @return [Column, nil] the updated column or nil+ def update(key, **options)+ column = @columns[key.to_sym]+ return nil unless column++ options.each do |attr, value|+ column.send("#{attr}=", value) if column.respond_to?("#{attr}=")+ end++ sort_columns!+ column+ end++ # Find a column by key+ # @param key [Symbol] column key+ # @return [Column, nil]+ def find(key)+ @columns[key.to_sym]+ end++ # Check if column exists+ # @param key [Symbol] column key+ # @return [Boolean]+ def exists?(key)+ @columns.key?(key.to_sym)+ end++ # Insert column before another column+ # @param target_key [Symbol] existing column key+ # @param new_key [Symbol] new column key+ # @param options [Hash] column options+ # @return [Column, nil]+ def insert_before(target_key, new_key, **options)+ target = find(target_key)+ return nil unless target++ add(new_key, **options.merge(position: target.position - 1))+ end++ # Insert column after another column+ # @param target_key [Symbol] existing column key+ # @param new_key [Symbol] new column key+ # @param options [Hash] column options+ # @return [Column, nil]+ def insert_after(target_key, new_key, **options)+ target = find(target_key)+ return nil unless target++ add(new_key, **options.merge(position: target.position + 1))+ end++ # Get visible columns for user (respecting selection)+ # @param selected_keys [Array<Symbol>, nil] user-selected column keys+ # @param view_context [Object, nil] view context for visibility checks+ # @return [Array<Column>]+ def visible_columns(selected_keys = nil, view_context = nil)+ cols = if selected_keys.present?+ selected_keys.map { |k| find(k) }.compact+ else+ default_columns+ end++ cols.select { |c| c.visible?(view_context) }+ end++ # Get default columns (marked as default: true and displayable)+ # @return [Array<Column>]+ def default_columns+ @columns.values.select { |c| c.default? && c.displayable? }.sort_by(&:position)+ end++ # Get all available columns that can be displayed+ # @return [Array<Column>]+ def available_columns+ @columns.values.select(&:displayable?).sort_by(&:position)+ end++ # Get sortable columns+ # @return [Array<Column>]+ def sortable_columns+ @columns.values.select(&:sortable?).sort_by(&:position)+ end++ # Get filterable columns (columns that can be used in query builder)+ # @return [Array<Column>]+ def filterable_columns+ @columns.values.select(&:filterable?).sort_by(&:position)+ end++ # Deep clone the registry+ # @return [RecordList]+ def deep_clone+ cloned = self.class.new(context, model_class: model_class, search_param: search_param, search_placeholder: search_placeholder)+ @columns.each do |key, column|+ cloned.columns[key] = column.deep_clone+ end+ cloned+ end++ # Clear all columns+ def clear+ @columns.clear+ end++ def inspect+ "#<Spree::Admin::RecordList context=#{context} columns=#{@columns.size}>"+ end++ private++ def sort_columns!+ @columns = @columns.sort_by { |_key, col| [col.position, col.key.to_s] }.to_h+ end+ end+ end+enddiff --git a/admin/app/models/spree/admin/record_list/builder.rb b/admin/app/models/spree/admin/record_list/builder.rbnew file mode 100644index 0000000000..1be6baa5e5--- /dev/null+++ b/admin/app/models/spree/admin/record_list/builder.rb@@ -0,0 +1,55 @@+module Spree+ module Admin+ class RecordList+ class Builder+ attr_reader :registry, :parent_column++ def initialize(registry, parent_column = nil)+ @registry = registry+ @parent_column = parent_column+ end++ # Add a column+ # @param key [Symbol] column key+ # @param options [Hash] column options+ # @return [Column]+ def add(key, **options, &block)+ @registry.add(key, **options, &block)+ end++ # Remove a column+ # @param key [Symbol] column key+ # @return [Column, nil]+ def remove(key)+ @registry.remove(key)+ end++ # Update a column+ # @param key [Symbol] column key+ # @param options [Hash] attributes to update+ # @return [Column, nil]+ def update(key, **options)+ @registry.update(key, **options)+ end++ # Insert before another column+ # @param target_key [Symbol] existing column key+ # @param new_key [Symbol] new column key+ # @param options [Hash] column options+ # @return [Column, nil]+ def insert_before(target_key, new_key, **options)+ @registry.insert_before(target_key, new_key, **options)+ end++ # Insert after another column+ # @param target_key [Symbol] existing column key+ # @param new_key [Symbol] new column key+ # @param options [Hash] column options+ # @return [Column, nil]+ def insert_after(target_key, new_key, **options)+ @registry.insert_after(target_key, new_key, **options)+ end+ end+ end+ end+enddiff --git a/admin/app/models/spree/admin/record_list/column.rb b/admin/app/models/spree/admin/record_list/column.rbnew file mode 100644index 0000000000..1bba790fee--- /dev/null+++ b/admin/app/models/spree/admin/record_list/column.rb@@ -0,0 +1,152 @@+module Spree+ module Admin+ class RecordList+ class Column+ TYPES = %i[string number date datetime currency status link boolean image custom].freeze+ FILTER_TYPES = %i[string number date datetime currency status boolean autocomplete].freeze++ attr_accessor :key, :label, :type, :filter_type, :sortable, :filterable, :displayable, :default, :position,+ :partial, :method, :width, :align, :format, :condition,+ :ransack_attribute, :operators, :value_options, :search_url++ def initialize(key, **options)+ @key = key.to_sym+ @label = options[:label]+ @type = (options[:type] || :string).to_sym+ @filter_type = (options[:filter_type] || @type).to_sym+ @sortable = options.fetch(:sortable, true)+ @filterable = options.fetch(:filterable, true)+ @displayable = options.fetch(:displayable, true)+ @default = options.fetch(:default, false)+ @position = options[:position] || 999+ @partial = options[:partial]+ @method = options[:method] || key+ @width = options[:width]+ @align = options[:align] || :left+ @format = options[:format]+ @condition = options.key?(:if) ? options[:if] : options[:condition]+ @ransack_attribute = options[:ransack_attribute] || key.to_s+ @value_options = options[:value_options]+ @search_url = options[:search_url]+ @operators = options[:operators] || default_operators_for_type+ end++ def sortable?+ @sortable+ end++ def filterable?+ @filterable+ end++ def displayable?+ @displayable+ end++ def default?+ @default+ end++ # Check if column is visible for the given context+ # @param context [Object, nil] view context with access to helper methods+ # @return [Boolean]+ def visible?(context = nil)+ return true if condition.nil?++ if condition.respond_to?(:call)+ if context&.respond_to?(:instance_exec)+ context.instance_exec(&condition)+ else+ condition.call(context)+ end+ else+ condition+ end+ end++ # Resolve label (handles i18n keys)+ # @return [String]+ def resolve_label+ if label.is_a?(String) && label.present?+ return label+ end++ key_to_translate = label || key+ Spree.t(key_to_translate, default: key_to_translate.to_s.humanize)+ end++ # Resolve value from record+ # @param record [Object] the record to extract value from+ # @param context [Object, nil] view context+ # @return [Object]+ def resolve_value(record, context = nil)+ if method.respond_to?(:call)+ if context&.respond_to?(:instance_exec)+ context.instance_exec(record, &method)+ else+ method.call(record)+ end+ elsif record.respond_to?(method)+ record.send(method)+ end+ end++ # Get default operators based on column filter_type+ # @return [Array<Symbol>]+ def default_operators_for_type+ case filter_type+ when :string+ %i[eq not_eq cont not_cont start end in not_in null not_null]+ when :number, :currency+ %i[eq not_eq gt gteq lt lteq in not_in null not_null]+ when :date, :datetime+ %i[eq not_eq gt gteq lt lteq null not_null]+ when :boolean+ %i[eq]+ when :status+ %i[eq not_eq in not_in]+ when :association, :tags, :autocomplete+ %i[in not_in]+ else+ %i[eq not_eq cont null not_null]+ end+ end++ # Convert to hash+ # @return [Hash]+ def to_h+ {+ key: key,+ label: label,+ type: type,+ filter_type: filter_type,+ sortable: sortable,+ filterable: filterable,+ displayable: displayable,+ default: default,+ position: position,+ partial: partial,+ method: method,+ width: width,+ align: align,+ format: format,+ ransack_attribute: ransack_attribute,+ operators: operators,+ value_options: value_options,+ search_url: search_url+ }+ end++ # Deep clone the column+ # @return [Column]+ def deep_clone+ self.class.new(key, to_h.merge(condition: condition, method: method))+ end++ def inspect+ "#<Spree::Admin::RecordList::Column key=#{key} type=#{type} default=#{default}>"+ end+ end+ end+ end+enddiff --git a/admin/app/models/spree/admin/record_list/filter.rb b/admin/app/models/spree/admin/record_list/filter.rbnew file mode 100644index 0000000000..af9159ca5f--- /dev/null+++ b/admin/app/models/spree/admin/record_list/filter.rb@@ -0,0 +1,109 @@+module Spree+ module Admin+ class RecordList+ class Filter+ OPERATORS = {+ eq: { label: 'equals', predicate: '_eq' },+ not_eq: { label: 'does not equal', predicate: '_not_eq' },+ cont: { label: 'contains', predicate: '_cont' },+ not_cont: { label: 'does not contain', predicate: '_not_cont' },+ start: { label: 'starts with', predicate: '_start' },+ end: { label: 'ends with', predicate: '_end' },+ gt: { label: 'greater than', predicate: '_gt' },+ gteq: { label: 'greater than or equal to', predicate: '_gteq' },+ lt: { label: 'less than', predicate: '_lt' },+ lteq: { label: 'less than or equal to', predicate: '_lteq' },+ in: { label: 'is any of', predicate: '_in' },+ not_in: { label: 'is none of', predicate: '_not_in' },+ null: { label: 'is empty', predicate: '_null', no_value: true },+ not_null: { label: 'is not empty', predicate: '_not_null', no_value: true }+ }.freeze++ attr_accessor :field, :operator, :value, :id++ def initialize(field: nil, operator: :eq, value: nil, id: nil)+ @field = field+ @operator = operator.to_sym+ @value = value+ @id = id || SecureRandom.hex(8)+ end++ # Convert to ransack parameter format+ # @return [Hash]+ def to_ransack_param+ return {} if field.blank?++ operator_config = OPERATORS[@operator]+ return {} unless operator_config++ param_name = "#{field}#{operator_config[:predicate]}"++ if operator_config[:no_value]+ { param_name => true }+ else+ { param_name => extract_ransack_value }+ end+ end++ private++ # Extract the actual value for ransack from potentially complex value structures+ # Handles arrays of objects (from autocomplete) by extracting IDs+ # @return [Object]+ def extract_ransack_value+ return value unless value.is_a?(Array)++ # If array contains hashes with 'id' key, extract the IDs+ if value.first.is_a?(Hash) && (value.first.key?('id') || value.first.key?(:id))+ value.map { |item| item['id'] || item[:id] }+ else+ value+ end+ end++ public++ # Get human-readable operator label+ # @return [String]+ def operator_label+ OPERATORS.dig(@operator, :label) || @operator.to_s.humanize+ end++ # Check if this operator requires a value+ # @return [Boolean]+ def requires_value?+ !OPERATORS.dig(@operator, :no_value)+ end++ # Convert to hash+ # @return [Hash]+ def to_h+ { field: field, operator: operator, value: value, id: id }+ end++ # Create filter from params hash+ # @param params [Hash]+ # @return [Filter, nil]+ def self.from_params(params)+ return nil unless params.is_a?(Hash)++ params = params.symbolize_keys+ new(+ field: params[:field],+ operator: params[:operator] || :eq,+ value: params[:value],+ id: params[:id]+ )+ end++ # Get available operators with labels for UI+ # @return [Array<Hash>]+ def self.operators_for_select+ OPERATORS.map do |key, config|+ { value: key.to_s, label: config[:label], no_value: config[:no_value] || false }+ end+ end+ end+ end+ end+enddiff --git a/admin/app/models/spree/admin/record_list/filter_group.rb b/admin/app/models/spree/admin/record_list/filter_group.rbnew file mode 100644index 0000000000..51bd668d1f--- /dev/null+++ b/admin/app/models/spree/admin/record_list/filter_group.rb@@ -0,0 +1,144 @@+module Spree+ module Admin+ class RecordList+ class FilterGroup+ COMBINATORS = %i[and or].freeze++ attr_accessor :combinator, :filters, :groups, :id++ def initialize(combinator: :and, filters: [], groups: [], id: nil)+ @combinator = combinator.to_sym+ @filters = filters+ @groups = groups+ @id = id || SecureRandom.hex(8)+ end++ # Add a filter to this group+ # @param filter [Filter]+ def add_filter(filter)+ @filters << filter+ end++ # Add a nested group+ # @param group [FilterGroup]+ def add_group(group)+ @groups << group+ end++ # Remove a filter by id+ # @param filter_id [String]+ def remove_filter(filter_id)+ @filters.reject! { |f| f.id == filter_id }+ end++ # Remove a nested group by id+ # @param group_id [String]+ def remove_group(group_id)+ @groups.reject! { |g| g.id == group_id }+ end++ # Check if group is empty+ # @return [Boolean]+ def empty?+ @filters.empty? && @groups.empty?+ end++ # Convert to ransack params format+ # AND groups use regular params: { name_cont: 'value', status_eq: 'active' }+ # OR groups use ransack groupings: { g: { '0' => { m: 'or', c: { ... } } } }+ # @return [Hash]+ def to_ransack_params+ if combinator == :or+ to_or_ransack_params+ else+ to_and_ransack_params+ end+ end++ # Convert to hash for JSON serialization+ # @return [Hash]+ def to_h+ {+ combinator: combinator,+ filters: filters.map(&:to_h),+ groups: groups.map(&:to_h),+ id: id+ }+ end++ # Create from params hash+ # @param params [Hash]+ # @return [FilterGroup]+ def self.from_params(params)+ return new if params.blank?++ params = params.symbolize_keys if params.respond_to?(:symbolize_keys)++ group = new(+ combinator: params[:combinator] || :and,+ id: params[:id]+ )++ Array(params[:filters]).each do |filter_params|+ filter = Filter.from_params(filter_params)+ group.add_filter(filter) if filter+ end++ Array(params[:groups]).each do |group_params|+ nested_group = from_params(group_params)+ group.add_group(nested_group) if nested_group+ end++ group+ end++ private++ def to_and_ransack_params+ result = {}++ filters.each do |filter|+ result.merge!(filter.to_ransack_param)+ end++ groups.each_with_index do |group, index|+ if group.combinator == :or+ result[:g] ||= {}+ result[:g][index.to_s] = build_or_grouping(group)+ else+ result.merge!(group.to_ransack_params)+ end+ end++ result+ end++ def to_or_ransack_params+ {+ g: {+ '0' => build_or_grouping(self)+ }+ }+ end++ def build_or_grouping(group)+ conditions = {}++ group.filters.each_with_index do |filter, index|+ param = filter.to_ransack_param+ next if param.empty?++ conditions[index.to_s] = {+ a: { '0' => { name: filter.field, p: filter.operator.to_s.sub('_', ''), v: { '0' => { value: filter.value } } } }+ }+ end++ {+ m: 'or',+ c: conditions+ }+ end+ end+ end+ end+enddiff --git a/admin/app/models/spree/admin/record_list/query_builder.rb b/admin/app/models/spree/admin/record_list/query_builder.rbnew file mode 100644index 0000000000..5dc05c4799--- /dev/null+++ b/admin/app/models/spree/admin/record_list/query_builder.rb@@ -0,0 +1,109 @@+module Spree+ module Admin+ class RecordList+ class QueryBuilder+ attr_reader :root_group, :record_list++ def initialize(record_list)+ @record_list = record_list+ @root_group = FilterGroup.new(combinator: :and)+ end++ # Add a filter to the root group+ # @param field [String] ransack attribute name+ # @param operator [Symbol] filter operator+ # @param value [Object] filter value+ # @return [Filter]+ def add_filter(field:, operator:, value:)+ filter = Filter.new(field: field, operator: operator, value: value)+ @root_group.add_filter(filter)+ filter+ end++ # Add a nested group+ # @param combinator [Symbol] :and or :or+ # @return [FilterGroup]+ def add_group(combinator: :and)+ group = FilterGroup.new(combinator: combinator)+ @root_group.add_group(group)+ group+ end++ # Clear all filters+ def clear+ @root_group = FilterGroup.new(combinator: :and)+ end++ # Check if there are any filters+ # @return [Boolean]+ def empty?+ @root_group.empty?+ end++ # Convert to ransack params format+ # @return [Hash]+ def to_ransack_params+ @root_group.to_ransack_params+ end++ # Convert to JSON string for storing in hidden field+ # @return [String]+ def to_json_state+ @root_group.to_h.to_json+ end++ # Load state from params hash+ # @param params [Hash]+ def load_from_params(params)+ @root_group = FilterGroup.from_params(params)+ end++ # Load state from JSON string+ # @param json_string [String]+ def load_from_json(json_string)+ return if json_string.blank?++ params = JSON.parse(json_string, symbolize_names: true)+ @root_group = FilterGroup.from_params(params)+ rescue JSON::ParserError+ @root_group = FilterGroup.new(combinator: :and)+ end++ # Get available fields for filtering based on record_list configuration+ # @return [Array<Hash>]+ def available_fields+ @record_list.filterable_columns.map do |column|+ {+ key: column.ransack_attribute,+ label: column.resolve_label,+ type: column.filter_type.to_s,+ operators: column.operators.map(&:to_s),+ value_options: format_value_options(column.value_options),+ search_url: column.search_url+ }+ end+ end++ # Get available operators for UI+ # @return [Array<Hash>]+ def available_operators+ Filter.operators_for_select+ end++ private++ def format_value_options(options)+ return nil if options.blank?++ options.map do |opt|+ if opt.is_a?(Hash)+ { value: opt[:value] || opt['value'], label: opt[:label] || opt['label'] }+ else+ { value: opt.to_s, label: opt.to_s.humanize }+ end+ end+ end+ end+ end+ end+enddiff --git a/admin/app/views/spree/admin/products/index.html.erb b/admin/app/views/spree/admin/products/index.html.erbindex 74890e49a3..662933f13a 100644--- a/admin/app/views/spree/admin/products/index.html.erb+++ b/admin/app/views/spree/admin/products/index.html.erb@@ -11,20 +11,7 @@<%= render_admin_partials(:products_header_partials) %>-<div class="card-lg">- <% if params[:frame_name].present? %>- <%= turbo_frame_tag params[:frame_name], autoscroll: true, data: { autoscroll_block: :start, autoscroll_behavior: :smooth } do %>- <%= render 'filters', frame_name: params[:frame_name] %>- <%= render 'list' %>- <% end %>- <% else %>- <%= turbo_frame_tag "products", autoscroll: true, data: { autoscroll_behavior: :smooth, turbo_action: 'advance' } do %>- <%= render 'spree/admin/shared/export_modal', export_type: Spree::Exports::Products %>- <%= render 'filters' %>- <%= render 'list' %>- <% end %>- <% end %>-</div>+<%= render_record_list @collection, :products, bulk_operations: true %><p class="documentation-link-container">Learn more aboutdiff --git a/admin/app/views/spree/admin/record_lists/_column_selector.html.erb b/admin/app/views/spree/admin/record_lists/_column_selector.html.erbnew file mode 100644index 0000000000..a20ff78551--- /dev/null+++ b/admin/app/views/spree/admin/record_lists/_column_selector.html.erb@@ -0,0 +1,53 @@+<%# locals: (record_list:, list_key:, selected_columns:) %>+<div data-controller="column-selector">+ <%= form_with url: spree.admin_record_list_columns_path,+ method: :post,+ data: { turbo_frame: '_top' } do |f| %>+ <%= hidden_field_tag :list_key, list_key %>++ <%= dropdown(portal: false) do %>+ <%= dropdown_toggle(class: 'btn-light btn-sm flex items-center gap-1') do %>+ <%= icon 'columns-3', class: 'w-4 h-4' %>+ <span><%= Spree.t('admin.record_lists.columns') %></span>+ <%= icon 'chevron-down', class: 'w-3 h-3' %>+ <% end %>++ <%= dropdown_menu(class: 'min-w-[250px] p-4') do %>+ <div class="mb-3">+ <h6 class="font-semibold text-gray-700 text-sm">+ <%= Spree.t('admin.record_lists.visible_columns') %>+ </h6>+ </div>++ <div class="space-y-2 max-h-[300px] overflow-y-auto mb-4">+ <% record_list.available_columns.each do |column| %>+ <% next unless column.visible?(self) %>+ <% is_selected = selected_columns.nil? ? column.default? : selected_columns.include?(column.key) %>+ <label class="flex items-center gap-2 cursor-pointer hover:bg-gray-50 p-1.5 rounded">+ <%= check_box_tag 'columns[]',+ column.key,+ is_selected,+ id: "column_#{column.key}",+ data: {+ column_selector_target: 'checkbox',+ default: column.default?+ },+ class: 'form-checkbox rounded' %>+ <span class="text-sm text-gray-700"><%= column.resolve_label %></span>+ </label>+ <% end %>+ </div>++ <div class="flex gap-2 pt-3 border-t border-gray-200">+ <button type="button"+ class="btn btn-sm btn-light flex-1"+ data-action="column-selector#reset">+ <%= Spree.t('admin.record_lists.reset_to_default') %>+ </button>+ <%= f.submit Spree.t('admin.record_lists.apply'),+ class: 'btn btn-sm btn-primary flex-1 cursor-pointer' %>+ </div>+ <% end %>+ <% end %>+ <% end %>+</div>diff --git a/admin/app/views/spree/admin/record_lists/_filter_group.html.erb b/admin/app/views/spree/admin/record_lists/_filter_group.html.erbnew file mode 100644index 0000000000..8b96d78da1--- /dev/null+++ b/admin/app/views/spree/admin/record_lists/_filter_group.html.erb@@ -0,0 +1,33 @@+<%# Template for a nested OR filter group - populated by JavaScript %>+<div class="p-4 border-2 border-dashed border-gray-300 rounded-lg bg-white"+ data-group-id=""+ data-combinator="or">+ <div class="flex items-center justify-between mb-3">+ <div class="flex items-center gap-2">+ <span class="text-sm text-gray-600"><%= Spree.t('admin.record_lists.match') %></span>+ <button type="button"+ class="btn btn-sm btn-outline-secondary px-2 py-1"+ data-action="query-builder#toggleGroupCombinator">+ <span data-group-combinator-label>OR</span>+ </button>+ <span class="text-sm text-gray-600"><%= Spree.t('admin.record_lists.of_the_following') %></span>+ </div>+ <button type="button"+ class="btn btn-sm btn-light text-red-600 hover:text-red-700 hover:bg-red-50 p-1.5"+ data-action="query-builder#removeGroup"+ title="<%= Spree.t(:remove) %>">+ <%= icon 'x', class: 'w-4 h-4' %>+ </button>+ </div>++ <div data-group-filters-container class="space-y-3 mb-3">+ <%# Filter rows within this group will be added here %>+ </div>++ <button type="button"+ class="btn btn-sm btn-light flex items-center gap-1"+ data-action="query-builder#addFilterToGroup">+ <%= icon 'plus', class: 'w-4 h-4' %>+ <%= Spree.t('admin.record_lists.add_filter') %>+ </button>+</div>diff --git a/admin/app/views/spree/admin/record_lists/_filter_row.html.erb b/admin/app/views/spree/admin/record_lists/_filter_row.html.erbnew file mode 100644index 0000000000..84418647b7--- /dev/null+++ b/admin/app/views/spree/admin/record_lists/_filter_row.html.erb@@ -0,0 +1,29 @@+<%# Template for a single filter row - populated by JavaScript %>+<div class="flex items-center gap-2 p-3 bg-gray-50 rounded-lg" data-filter-id="">+ <select class="form-select flex-1 text-sm"+ data-field-select+ data-action="change->query-builder#onFieldChange">+ <option value=""><%= Spree.t('admin.record_lists.select_field') %></option>+ </select>++ <select class="form-select flex-shrink-0 w-[160px] text-sm"+ data-operator-select+ data-action="change->query-builder#onOperatorChange">+ <option value="eq"><%= Spree.t('admin.record_lists.operators.equals') %></option>+ </select>++ <div data-value-container class="flex-1">+ <input type="text"+ class="form-input text-sm"+ placeholder="<%= Spree.t('admin.record_lists.enter_value') %>"+ data-value-input+ data-action="input->query-builder#onValueChange">+ </div>++ <button type="button"+ class="btn btn-sm btn-light text-red-600 hover:text-red-700 hover:bg-red-50 p-1.5"+ data-action="query-builder#removeFilter"+ title="<%= Spree.t(:remove) %>">+ <%= icon 'x', class: 'w-4 h-4' %>+ </button>+</div>diff --git a/admin/app/views/spree/admin/record_lists/_query_builder.html.erb b/admin/app/views/spree/admin/record_lists/_query_builder.html.erbnew file mode 100644index 0000000000..44e6da5942--- /dev/null+++ b/admin/app/views/spree/admin/record_lists/_query_builder.html.erb@@ -0,0 +1,92 @@+<%# locals: (record_list:, list_key:) %>+<% fields_json = query_builder_fields_json(record_list) %>+<% operators_json = query_builder_operators_json %>+<% current_state = params[:query_state] || '{}' %>++<div data-controller="dialog">+ <button type="button"+ class="btn btn-light btn-sm flex items-center gap-1"+ data-action="dialog#open">+ <%= icon 'filter', class: 'w-4 h-4' %>+ <span><%= Spree.t('admin.record_lists.filters') %></span>+ </button>++ <dialog class="drawer"+ data-dialog-target="dialog"+ id="query-builder-drawer-<%= list_key %>">+ <%= drawer_header(Spree.t('admin.record_lists.filter_builder'), 'dialog') %>++ <div data-controller="query-builder"+ data-query-builder-fields-value="<%= fields_json %>"+ data-query-builder-operators-value="<%= operators_json %>">++ <%= form_with url: url_for, method: :get, data: { turbo_frame: '_top', query_builder_target: 'form', action: 'submit->query-builder#submitForm' } do |f| %>+ <div class="drawer-body">+ <div class="mb-4 flex items-center gap-2 flex-wrap">+ <span class="text-sm text-gray-600">+ <%= Spree.t('admin.record_lists.match') %>+ </span>+ <button type="button"+ class="btn btn-sm btn-outline-secondary px-2 py-1"+ data-action="query-builder#toggleCombinator"+ data-query-builder-target="combinatorButton">+ <span data-query-builder-target="combinatorLabel">AND</span>+ </button>+ <span class="text-sm text-gray-600">+ <%= Spree.t('admin.record_lists.of_the_following') %>+ </span>+ </div>++ <div data-query-builder-target="filtersContainer" class="space-y-3 mb-4">+ <%# Filter rows will be added here dynamically %>+ </div>++ <div data-query-builder-target="groupsContainer" class="space-y-3 mb-4">+ <%# Nested groups will be added here %>+ </div>++ <div class="flex gap-2">+ <button type="button"+ class="btn btn-sm btn-light flex items-center gap-1"+ data-action="query-builder#addFilter">+ <%= icon 'plus', class: 'w-4 h-4' %>+ <%= Spree.t('admin.record_lists.add_filter') %>+ </button>+ <button type="button"+ class="btn btn-sm btn-light flex items-center gap-1"+ data-action="query-builder#addOrGroup">+ <%= icon 'brackets', class: 'w-4 h-4' %>+ <%= Spree.t('admin.record_lists.add_or_group') %>+ </button>+ </div>++ <input type="hidden"+ name="query_state"+ data-query-builder-target="hiddenInput"+ value="<%= h current_state %>">+ </div>++ <div class="drawer-footer">+ <%= drawer_discard_button('dialog') %>+ <button type="button"+ class="btn btn-light"+ data-action="query-builder#clear">+ <%= Spree.t('admin.record_lists.clear_all') %>+ </button>+ <%= f.submit Spree.t('admin.record_lists.apply_filters'),+ class: 'btn btn-primary cursor-pointer' %>+ </div>+ <% end %>++ <%# Filter row template %>+ <template data-query-builder-target="filterTemplate">+ <%= render 'spree/admin/record_lists/filter_row' %>+ </template>++ <%# Filter group template %>+ <template data-query-builder-target="groupTemplate">+ <%= render 'spree/admin/record_lists/filter_group' %>+ </template>+ </div>+ </dialog>+</div>diff --git a/admin/app/views/spree/admin/record_lists/_record_list.html.erb b/admin/app/views/spree/admin/record_lists/_record_list.html.erbnew file mode 100644index 0000000000..cc1eae3542--- /dev/null+++ b/admin/app/views/spree/admin/record_lists/_record_list.html.erb@@ -0,0 +1,49 @@+<%# locals: (collection:, record_list:, list_key:, selected_columns: nil, frame_name: nil, bulk_operations: false, sortable: false) %>+<% frame_name ||= controller_name %>+<% columns = record_list.visible_columns(selected_columns, self) %>+<% current_sort = params.dig(:q, :s) %>+<% search_param = record_list.respond_to?(:search_param) ? record_list.search_param : :name_cont %>+<% search_placeholder = (record_list.respond_to?(:search_placeholder) && record_list.search_placeholder) || [Spree.t(:search), controller_name.humanize.downcase].join(' ') %>++<%= turbo_frame_tag frame_name, autoscroll: true, data: { autoscroll_block: :start, turbo_action: 'advance' } do %>+ <div class="card-lg" data-controller="record-list" data-record-list-url-value="<%= request.path %>">+ <div class="p-4 border-b border-gray-200">+ <%= search_form_for @search, url: url_for, html: { data: { turbo_frame: frame_name, turbo_action: 'advance' } } do |f| %>+ <div class="flex flex-col lg:flex-row gap-3 items-start lg:items-center justify-between">+ <div class="flex gap-2 items-center flex-wrap grow">+ <div class="form-input flex items-center py-0 focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-blue-500 grow max-lg:max-w-[300px] mr-auto h-[2.125rem] transition-all duration-100 ease-in-out">+ <%= icon "search", class: "mr-4 text-gray-600" %>+ <%= search_field_tag "q[#{search_param}]",+ params.dig(:q, search_param),+ class: "outline-none border-0 h-full focus:border-0 focus:ring-0 p-0 text-base w-full",+ placeholder: search_placeholder %>+ </div>+ <%= render 'spree/admin/record_lists/query_builder', record_list: record_list, list_key: list_key %>+ </div>++ <div class="flex gap-2 items-center">+ <%= record_list_sort_dropdown(record_list, current_sort) %>+ <%= render 'spree/admin/record_lists/column_selector',+ record_list: record_list,+ list_key: list_key,+ selected_columns: selected_columns %>+ </div>+ </div>+ <% end %>+ </div>++ <% if collection.any? %>+ <%= render 'spree/admin/record_lists/table',+ collection: collection,+ columns: columns,+ record_list: record_list,+ bulk_operations: bulk_operations,+ sortable: sortable %>++ <%= render 'spree/admin/shared/index_table_options', collection: collection %>+ <% else %>+ <%= render 'spree/admin/shared/no_resource_found',+ new_object_url: (new_object_url if respond_to?(:new_object_url) && can?(:create, record_list.model_class)) %>+ <% end %>+ </div>+<% end %>diff --git a/admin/app/views/spree/admin/record_lists/_row_actions.html.erb b/admin/app/views/spree/admin/record_lists/_row_actions.html.erbnew file mode 100644index 0000000000..8744113f73--- /dev/null+++ b/admin/app/views/spree/admin/record_lists/_row_actions.html.erb@@ -0,0 +1,24 @@+<%# locals: (record:) %>+<div class="flex items-center justify-end gap-1 opacity-0 group-hover:opacity-100 transition-opacity">+ <% if respond_to?(:edit_object_url) && can?(:update, record) %>+ <%= link_to edit_object_url(record),+ class: 'btn btn-sm btn-light',+ title: Spree.t(:edit),+ data: { 'turbo-frame': '_top' } do %>+ <%= icon 'pencil', class: 'w-4 h-4' %>+ <% end %>+ <% end %>++ <% if respond_to?(:object_url) && can?(:destroy, record) %>+ <%= link_to object_url(record),+ method: :delete,+ class: 'btn btn-sm btn-light text-red-600 hover:text-red-700',+ title: Spree.t(:delete),+ data: {+ turbo_method: :delete,+ turbo_confirm: Spree.t(:are_you_sure)+ } do %>+ <%= icon 'trash', class: 'w-4 h-4' %>+ <% end %>+ <% end %>+</div>diff --git a/admin/app/views/spree/admin/record_lists/_table.html.erb b/admin/app/views/spree/admin/record_lists/_table.html.erbnew file mode 100644index 0000000000..b600ae176d--- /dev/null+++ b/admin/app/views/spree/admin/record_lists/_table.html.erb@@ -0,0 +1,92 @@+<%# locals: (collection:, columns:, record_list:, bulk_operations: false, sortable: false) %>+<% if bulk_operations %>+ <div data-controller="bulk-operation bulk-dialog" data-action="keydown.esc->bulk-operation#cancel" tabindex="0">+ <%= form_tag url_for(action: :index), method: :put, data: { 'bulk-operation-target': 'form' } do %>+ <%= render 'spree/admin/shared/bulk_modal' %>++ <div class="table-responsive">+ <table class="table" id="listing_<%= controller_name %>">+ <thead>+ <tr>+ <th scope="col" class="pr-0 w-5">+ <%= bulk_operations_select_all_checkbox %>+ </th>++ <% columns.each do |column| %>+ <th scope="col" class="<%= column_header_class(column) %>">+ <% if column.sortable? && @search %>+ <%= sort_link @search, column.ransack_attribute, column.resolve_label,+ default_order: 'desc',+ title: "#{controller_name}_listing_#{column.key}_title" %>+ <% else %>+ <%= column.resolve_label %>+ <% end %>+ </th>+ <% end %>++ <th scope="col" class="w-10"></th>+ </tr>+ </thead>+ <tbody+ <% if sortable %>+ data-controller="sortable"+ data-sortable-handle-value=".move-handle"+ data-sortable-resource-name-value="<%= controller_name.singularize %>"+ data-sortable-response-kind-value="turbo-stream"+ <% end %>+ >+ <%= render partial: 'spree/admin/record_lists/table_row',+ collection: collection,+ as: :record,+ locals: {+ columns: columns,+ record_list: record_list,+ bulk_operations: bulk_operations,+ sortable: sortable+ } %>+ </tbody>+ </table>+ </div>+ <% end %>+ </div>+<% else %>+ <div class="table-responsive">+ <table class="table" id="listing_<%= controller_name %>">+ <thead>+ <tr>+ <% columns.each do |column| %>+ <th scope="col" class="<%= column_header_class(column) %>">+ <% if column.sortable? && @search %>+ <%= sort_link @search, column.ransack_attribute, column.resolve_label,+ default_order: 'desc',+ title: "#{controller_name}_listing_#{column.key}_title" %>+ <% else %>+ <%= column.resolve_label %>+ <% end %>+ </th>+ <% end %>++ <th scope="col" class="w-10"></th>+ </tr>+ </thead>+ <tbody+ <% if sortable %>+ data-controller="sortable"+ data-sortable-handle-value=".move-handle"+ data-sortable-resource-name-value="<%= controller_name.singularize %>"+ data-sortable-response-kind-value="turbo-stream"+ <% end %>+ >+ <%= render partial: 'spree/admin/record_lists/table_row',+ collection: collection,+ as: :record,+ locals: {+ columns: columns,+ record_list: record_list,+ bulk_operations: false,+ sortable: sortable+ } %>+ </tbody>+ </table>+ </div>+<% end %>diff --git a/admin/app/views/spree/admin/record_lists/_table_row.html.erb b/admin/app/views/spree/admin/record_lists/_table_row.html.erbnew file mode 100644index 0000000000..b142816ac9--- /dev/null+++ b/admin/app/views/spree/admin/record_lists/_table_row.html.erb@@ -0,0 +1,26 @@+<%# locals: (record:, columns:, record_list:, bulk_operations: false, sortable: false) %>+<tr id="<%= dom_id record %>" class="group">+ <% if bulk_operations %>+ <td class="pr-0 w-5">+ <%= bulk_operations_checkbox(record) %>+ </td>+ <% end %>++ <% columns.each_with_index do |column, index| %>+ <td class="<%= column_cell_class(column) %>">+ <% if index == 0 %>+ <%= link_to edit_object_url(record),+ class: 'flex items-center w-full no-underline hover:text-primary',+ data: { 'turbo-frame': '_top' } do %>+ <%= render_column_value(record, column, record_list) %>+ <% end %>+ <% else %>+ <%= render_column_value(record, column, record_list) %>+ <% end %>+ </td>+ <% end %>++ <td class="w-10 text-right">+ <%= render 'spree/admin/record_lists/row_actions', record: record %>+ </td>+</tr>diff --git a/admin/app/views/spree/admin/record_lists/columns/_product_inventory.html.erb b/admin/app/views/spree/admin/record_lists/columns/_product_inventory.html.erbnew file mode 100644index 0000000000..1bf4065846--- /dev/null+++ b/admin/app/views/spree/admin/record_lists/columns/_product_inventory.html.erb@@ -0,0 +1,3 @@+<%# locals: (record:, column:, value:) %>+<% product = record %>+<%= display_inventory(product) %>diff --git a/admin/app/views/spree/admin/record_lists/columns/_product_name.html.erb b/admin/app/views/spree/admin/record_lists/columns/_product_name.html.erbnew file mode 100644index 0000000000..4703828e51--- /dev/null+++ b/admin/app/views/spree/admin/record_lists/columns/_product_name.html.erb@@ -0,0 +1,8 @@+<%# locals: (record:, column:, value:) %>+<% product = record %>+<div class="flex items-center gap-3">+ <%= render 'spree/admin/shared/product_image', object: product %>+ <span class="text-gray-900 font-medium">+ <%= product.name %>+ </span>+</div>diff --git a/admin/app/views/spree/admin/record_lists/columns/_product_status.html.erb b/admin/app/views/spree/admin/record_lists/columns/_product_status.html.erbnew file mode 100644index 0000000000..ab73fd56c4--- /dev/null+++ b/admin/app/views/spree/admin/record_lists/columns/_product_status.html.erb@@ -0,0 +1,6 @@+<%# locals: (record:, column:, value:) %>+<% product = record %>+<div class="text-center">+ <%= product_status(product) %>+ <%= help_bubble(Spree.t("admin.products.help_bubble")) %>+</div>diff --git a/admin/config/initializers/record_lists.rb b/admin/config/initializers/record_lists.rbnew file mode 100644index 0000000000..5da46ee761--- /dev/null+++ b/admin/config/initializers/record_lists.rb@@ -0,0 +1,331 @@+# Default column configurations for Spree Admin Record Lists+#+# This initializer registers the default record lists and their columns.+# Developers can extend these in their own initializers by:+#+# Rails.application.config.after_initialize do+# Spree.admin.record_lists.products.add :custom_column, type: :string, default: true+# Spree.admin.record_lists.products.remove :sku+# Spree.admin.record_lists.products.update :name, position: 5+# Spree.admin.record_lists.products.insert_after :name, :vendor, type: :string+# end++Rails.application.config.after_initialize do+ # Register Products record list+ Spree.admin.record_lists.register(:products, model_class: Spree::Product, search_param: :multi_search)++ # Product name with image (custom partial)+ Spree.admin.record_lists.products.add :name,+ label: :name,+ type: :custom,+ sortable: true,+ filterable: true,+ default: true,+ position: 10,+ partial: 'spree/admin/record_lists/columns/product_name'++ # Product status with help bubble (custom partial)+ Spree.admin.record_lists.products.add :status,+ label: :status,+ type: :custom,+ filter_type: :status,+ sortable: true,+ filterable: true,+ default: true,+ position: 20,+ partial: 'spree/admin/record_lists/columns/product_status',+ value_options: [+ { value: 'draft', label: 'Draft' },+ { value: 'active', label: 'Active' },+ { value: 'archived', label: 'Archived' }+ ]++ # Inventory display (custom partial)+ Spree.admin.record_lists.products.add :inventory,+ label: :inventory,+ type: :custom,+ sortable: false,+ filterable: false,+ default: true,+ position: 25,+ partial: 'spree/admin/record_lists/columns/product_inventory'++ Spree.admin.record_lists.products.add :sku,+ label: :sku,+ type: :string,+ sortable: true,+ filterable: true,+ default: false,+ position: 30,+ ransack_attribute: 'master_sku',+ method: ->(product) { product.sku }++ Spree.admin.record_lists.products.add :price,+ label: :price,+ type: :currency,+ sortable: true,+ filterable: true,+ default: true,+ position: 40,+ ransack_attribute: 'master_price',+ method: ->(product) { product.price }++ Spree.admin.record_lists.products.add :created_at,+ label: :created_at,+ type: :datetime,+ sortable: true,+ filterable: true,+ default: false,+ position: 50++ Spree.admin.record_lists.products.add :updated_at,+ label: :updated_at,+ type: :datetime,+ sortable: true,+ filterable: true,+ default: false,+ position: 60++ # Stock filter (filter-only, not displayed as column)+ Spree.admin.record_lists.products.add :in_stock,+ label: 'In Stock',+ type: :boolean,+ filter_type: :boolean,+ sortable: false,+ filterable: true,+ displayable: false,+ default: false,+ position: 70,+ ransack_attribute: 'in_stock_items'++ # Taxons - displayed as comma-separated list, filtered via autocomplete+ Spree.admin.record_lists.products.add :taxons,+ label: :taxons,+ type: :association,+ filter_type: :autocomplete,+ sortable: false,+ filterable: true,+ default: false,+ position: 80,+ ransack_attribute: 'taxons_id',+ operators: %i[in],+ search_url: '/admin/taxons/select_options.json',+ method: ->(product) { product.taxons.map(&:pretty_name).join(', ') }++ # Tags - displayed as comma-separated list, filtered via autocomplete+ Spree.admin.record_lists.products.add :tags,+ label: :tags,+ type: :association,+ filter_type: :autocomplete,+ sortable: false,+ filterable: true,+ default: false,+ position: 85,+ ransack_attribute: 'tags_name',+ operators: %i[in],+ search_url: '/admin/tags/select_options.json?taggable_type=Spree::Product',+ method: ->(product) { product.tag_list.join(', ') }++ # Register Orders record list+ Spree.admin.record_lists.register(:orders, model_class: Spree::Order, search_param: :number_or_email_cont)++ Spree.admin.record_lists.orders.add :number,+ label: :order_number,+ type: :link,+ sortable: true,+ filterable: true,+ default: true,+ position: 10++ Spree.admin.record_lists.orders.add :state,+ label: :state,+ type: :status,+ sortable: true,+ filterable: true,+ default: true,+ position: 20,+ value_options: [+ { value: 'cart', label: 'Cart' },+ { value: 'address', label: 'Address' },+ { value: 'delivery', label: 'Delivery' },+ { value: 'payment', label: 'Payment' },+ { value: 'confirm', label: 'Confirm' },+ { value: 'complete', label: 'Complete' },+ { value: 'canceled', label: 'Canceled' }+ ]++ Spree.admin.record_lists.orders.add :payment_state,+ label: :payment_state,+ type: :status,+ sortable: true,+ filterable: true,+ default: true,+ position: 30,+ value_options: [+ { value: 'balance_due', label: 'Balance Due' },+ { value: 'credit_owed', label: 'Credit Owed' },+ { value: 'failed', label: 'Failed' },+ { value: 'paid', label: 'Paid' },+ { value: 'void', label: 'Void' }+ ]++ Spree.admin.record_lists.orders.add :shipment_state,+ label: :shipment_state,+ type: :status,+ sortable: true,+ filterable: true,+ default: false,+ position: 35,+ value_options: [+ { value: 'backorder', label: 'Backorder' },+ { value: 'canceled', label: 'Canceled' },+ { value: 'partial', label: 'Partial' },+ { value: 'pending', label: 'Pending' },+ { value: 'ready', label: 'Ready' },+ { value: 'shipped', label: 'Shipped' }+ ]++ Spree.admin.record_lists.orders.add :total,+ label: :total,+ type: :currency,+ sortable: true,+ filterable: true,+ default: true,+ position: 40,+ method: ->(order) { order.display_total }++ Spree.admin.record_lists.orders.add :email,+ label: :email,+ type: :string,+ sortable: true,+ filterable: true,+ default: false,+ position: 45++ Spree.admin.record_lists.orders.add :completed_at,+ label: :completed_at,+ type: :datetime,+ sortable: true,+ filterable: true,+ default: true,+ position: 50++ Spree.admin.record_lists.orders.add :created_at,+ label: :created_at,+ type: :datetime,+ sortable: true,+ filterable: true,+ default: false,+ position: 60++ # Register Users record list+ Spree.admin.record_lists.register(:users, model_class: Spree.user_class, search_param: :email_cont)++ Spree.admin.record_lists.users.add :email,+ label: :email,+ type: :link,+ sortable: true,+ filterable: true,+ default: true,+ position: 10++ Spree.admin.record_lists.users.add :first_name,+ label: :first_name,+ type: :string,+ sortable: true,+ filterable: true,+ default: true,+ position: 20,+ ransack_attribute: 'bill_address_firstname'++ Spree.admin.record_lists.users.add :last_name,+ label: :last_name,+ type: :string,+ sortable: true,+ filterable: true,+ default: true,+ position: 30,+ ransack_attribute: 'bill_address_lastname'++ Spree.admin.record_lists.users.add :created_at,+ label: :created_at,+ type: :datetime,+ sortable: true,+ filterable: true,+ default: true,+ position: 40++ # Register Promotions record list+ Spree.admin.record_lists.register(:promotions, model_class: Spree::Promotion, search_param: :name_cont)++ Spree.admin.record_lists.promotions.add :name,+ label: :name,+ type: :link,+ sortable: true,+ filterable: true,+ default: true,+ position: 10++ Spree.admin.record_lists.promotions.add :code,+ label: :code,+ type: :string,+ sortable: true,+ filterable: true,+ default: true,+ position: 20++ Spree.admin.record_lists.promotions.add :starts_at,+ label: :starts_at,+ type: :datetime,+ sortable: true,+ filterable: true,+ default: true,+ position: 30++ Spree.admin.record_lists.promotions.add :expires_at,+ label: :expires_at,+ type: :datetime,+ sortable: true,+ filterable: true,+ default: true,+ position: 40++ # Register Posts record list+ Spree.admin.record_lists.register(:posts, model_class: Spree::Post, search_param: :title_cont)++ Spree.admin.record_lists.posts.add :title,+ label: :title,+ type: :link,+ sortable: true,+ filterable: true,+ default: true,+ position: 10++ Spree.admin.record_lists.posts.add :status,+ label: :status,+ type: :status,+ sortable: true,+ filterable: true,+ default: true,+ position: 20,+ value_options: [+ { value: 'draft', label: 'Draft' },+ { value: 'published', label: 'Published' }+ ]++ Spree.admin.record_lists.posts.add :published_at,+ label: :published_at,+ type: :datetime,+ sortable: true,+ filterable: true,+ default: true,+ position: 30++ Spree.admin.record_lists.posts.add :created_at,+ label: :created_at,+ type: :datetime,+ sortable: true,+ filterable: true,+ default: false,+ position: 40+enddiff --git a/admin/config/locales/en.yml b/admin/config/locales/en.ymlindex b615334c1d..bdee044f42 100644--- a/admin/config/locales/en.yml+++ b/admin/config/locales/en.yml@@ -338,3 +338,34 @@ en:subscriptions: Subscriptionstime_of_last_event: Time of Last Eventwebhooks_events: Webhooks Events+ record_lists:+ add_filter: Add filter+ add_or_group: Add OR group+ apply: Apply+ apply_filters: Apply Filters+ clear_all: Clear All+ columns: Columns+ enter_value: Enter value...+ filter_builder: Filter Builder+ filters: Filters+ match: Match+ of_the_following: of the following+ operators:+ contains: contains+ does_not_contain: does not contain+ ends_with: ends with+ equals: equals+ greater_than: greater than+ greater_than_or_equal: greater than or equal+ is_any_of: is any of+ is_empty: is empty+ is_none_of: is none of+ is_not_empty: is not empty+ less_than: less than+ less_than_or_equal: less than or equal+ not_equals: does not equal+ starts_with: starts with+ reset_to_default: Reset to Default+ select_field: Select field...+ sort_by: Sort by+ visible_columns: Visible Columnsdiff --git a/admin/config/routes.rb b/admin/config/routes.rbindex 9a108333bd..647d0dcb8b 100644--- a/admin/config/routes.rb+++ b/admin/config/routes.rb@@ -44,6 +44,7 @@ Spree::Core::Engine.add_routes doresources :classifications, only: %i[index new create update destroy]endget '/taxons/select_options' => 'taxons#select_options', as: :taxons_select_options, defaults: { format: :json }+ get '/tags/select_options' => 'tags#select_options', as: :tags_select_options, defaults: { format: :json }# media libraryresources :assets, only: [:create, :edit, :update, :destroy] do@@ -230,6 +231,9 @@ Spree::Core::Engine.add_routes doget '/errors/:path', to: 'errors#show', as: :pathed_errorsend+ # record list columns (for session-based column selection)+ post 'record_list_columns', to: 'record_list_columns#update', as: :record_list_columns+# dashboardresource :dashboard, controller: 'dashboard'get '/dashboard/analytics', to: 'dashboard#analytics', as: :dashboard_analyticsdiff --git a/admin/lib/spree/admin.rb b/admin/lib/spree/admin.rbindex 205854f0cb..cb57e17cdb 100644--- a/admin/lib/spree/admin.rb+++ b/admin/lib/spree/admin.rb@@ -37,5 +37,9 @@ module Spreedef navigationRails.application.config.spree_admin.navigationend++ def record_lists+ Rails.application.config.spree_admin.record_lists+ endendenddiff --git a/admin/lib/spree/admin/engine.rb b/admin/lib/spree/admin/engine.rbindex d4273a5ea7..d9a95ccea1 100644--- a/admin/lib/spree/admin/engine.rb+++ b/admin/lib/spree/admin/engine.rb@@ -126,7 +126,8 @@ module Spree:vendors_nav_partials,:zones_actions_partials,:zones_header_partials,- :navigation+ :navigation,+ :record_lists)class NavigationEnvironment@@ -178,6 +179,58 @@ module Spreeendend+ class RecordListsEnvironment+ def initialize+ @registries = {}+ end++ # Register a new record list+ # @param name [Symbol] The name of the record list (e.g., :products, :orders)+ # @param model_class [Class, nil] The model class for this list+ # @param search_param [Symbol] The ransack parameter for text search (default: :name_cont)+ # @param search_placeholder [String, nil] Custom placeholder for search field+ # @return [Spree::Admin::RecordList] The record list instance+ def register(name, model_class: nil, search_param: :name_cont, search_placeholder: nil)+ name = name.to_sym+ @registries[name] ||= Spree::Admin::RecordList.new(name, model_class: model_class, search_param: search_param, search_placeholder: search_placeholder)+ end++ # Get a registered record list+ # @param name [Symbol] The name of the record list+ # @return [Spree::Admin::RecordList] The record list instance+ # @raise [NoMethodError] if the record list hasn't been registered+ def get(name)+ name = name.to_sym+ @registries[name] || raise(NoMethodError, "Record list '#{name}' has not been registered. Use Spree.admin.record_lists.register(:#{name}) first.")+ end++ # Check if a record list is registered+ # @param name [Symbol] The record list name+ # @return [Boolean]+ def registered?(name)+ @registries.key?(name.to_sym)+ end++ # List all registered record lists+ # @return [Array<Symbol>]+ def registries+ @registries.keys+ end++ # Define accessor methods for registered record lists+ def method_missing(method_name, *args)+ if method_name.to_s.end_with?('=')+ super+ else+ get(method_name)+ end+ end++ def respond_to_missing?(method_name, include_private = false)+ method_name.to_s.end_with?('=') ? false : registered?(method_name)+ end+ end+# Add app/subscribers to autoload pathsconfig.paths.add 'app/subscribers', eager_load: true@@ -254,6 +307,9 @@ module Spreeapp.config.spree_admin.navigation.register_context(:returns_tabs)app.config.spree_admin.navigation.register_context(:developers_tabs)app.config.spree_admin.navigation.register_context(:audit_tabs)++ # Register record lists environment+ app.config.spree_admin.record_lists = RecordListsEnvironment.newend# Add admin event subscribers