refine-rails 2.9.0

data/app/controllers/refine/blueprints_controller.rb

@@ -0,0 +1,80 @@
+module Refine
+  class BlueprintsController < ApplicationController
+    layout false
+    before_action :set_builder
+    before_action :set_filter
+    before_action :set_form
+
+    # entry point for initial render of the filter builder
+    def new
+      @show_stored_filters = params[:stored_filters]
+    end
+
+    # refresh the filter builder
+    def show
+      if @refine_filter_query.valid?
+        @stable_id = @refine_filter.to_stable_id
+      end
+
+      # don't display errors
+      include_errors = ActiveRecord::Type::Boolean.new.cast(params[:include_errors])
+      @refine_filter_query.clear_errors unless include_errors
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html
+      end
+    end
+
+    # handles filter submission
+    def create
+      if @refine_filter_query.valid?
+        # set stable_id
+        @stable_id = @refine_filter.to_stable_id
+
+        # set url
+        uri = URI(request.referrer)
+        new_query_ar = URI.decode_www_form(String(uri.query))
+        new_query_ar.reject! { |(k, _v)| k == "stable_id" }
+        new_query_ar << ["stable_id", @stable_id]
+        uri.query = URI.encode_www_form(new_query_ar)
+        @url_for_redirect = uri.to_s
+        @filter_submit_success = true
+      end
+    end
+
+    def stored_filters
+      render partial: "stored_filters", layout: false
+    end
+
+    def validate
+      if @refine_filter_query.valid?
+        head :ok
+      else
+        head :unprocessable_entity
+      end
+    end
+
+    private
+
+    def set_builder
+      builder_params = params.require(:refine_filters_builder).permit(
+        :blueprint_json,
+        :filter_class,
+        :stable_id,
+        :stored_filter_id,
+        :client_id
+      )
+
+      @refine_filter_builder = Refine::Filters::Builder.new(builder_params)
+    end
+
+    def set_filter
+      @refine_filter = @refine_filter_builder.refine_filter
+    end
+
+    def set_form
+      @refine_filter_query = @refine_filter_builder.query
+    end
+  end
+end

data/app/controllers/refine/filter_application_controller.rb

@@ -0,0 +1,29 @@
+module Refine::FilterApplicationController 
+	# Optional module to get started quickly.You can send in the current controller's instance variable if you'd like to update the collection here
+  # The current scope can be used to modify the query
+
+
+  def apply_filter(filter_class, initial_query: nil)
+    if filter_class.present?
+      @stable_id = params[:stable_id]
+      @refine_filter_builder = Refine::Filters::Builder.new(
+        stable_id: @stable_id,
+        filter_class: filter_class.name,
+        initial_query: initial_query)
+      @refine_filter = @refine_filter_builder.refine_filter
+    end
+  end
+
+  # Use this on pages that use the new inline filter
+  def apply_inline_filter(filter_class, initial_query: nil)
+    stable_id = params[:stable_id]
+
+    if stable_id.present?
+      @refine_filter = Refine::Rails.configuration.stabilizer_classes[:url].new.from_stable_id(id: stable_id, initial_query: initial_query)
+    else
+      @refine_filter = filter_class.new([], initial_query)
+    end
+    @refine_client_id = SecureRandom.uuid
+    @refine_stable_id = @refine_filter.to_stable_id
+  end
+end

data/app/controllers/refine/inline/criteria_controller.rb

@@ -0,0 +1,161 @@
+class Refine::Inline::CriteriaController < ApplicationController
+  layout false
+  before_action :set_refine_filter
+
+  # List available conditions for new criteria
+  # Carries position and index forward
+  def index
+    @criterion = Refine::Inline::Criterion.new(criterion_params.merge(refine_filter: @refine_filter))
+    @conditions = @refine_filter.instantiated_conditions
+  end
+
+  # Show the form to add a new criteria
+  def new
+    @criterion = Refine::Inline::Criterion.new(criterion_params.merge(refine_filter: @refine_filter))
+    respond_to do |format|
+      # render a turbo_stream so that we can render inputs and forms in separate areas of the page
+      # in case we're nested inside a form
+      format.turbo_stream
+    end
+  end
+
+  # Create a new criterion
+  def create
+    @criterion = Refine::Inline::Criterion.new(criterion_params.merge(refine_filter: @refine_filter))
+    blueprint = @refine_filter.blueprint
+
+    Refine::Filters::BlueprintEditor
+      .new(@refine_filter.blueprint)
+      .add(
+        position: @criterion.position.to_i,
+        conjunction: @criterion.conjunction,
+        criterion: @criterion.to_blueprint_node
+      )
+
+    @error_messages = filter_error_messages(@refine_filter)
+    if @error_messages.none?
+      handle_filter_update(@refine_filter.to_stable_id)
+    else
+      respond_to do |format|
+        format.turbo_stream { render :new }
+      end
+    end
+  end
+
+  # show the form to edit an existing criterion
+  def edit
+    @criterion = Refine::Inline::Criterion
+      .groups_from_filter(@refine_filter, **criterion_params.slice(:client_id, :stable_id))
+      .flatten
+      .detect { |c| c.position.to_s == params[:id] }
+
+    @criterion.attributes = criterion_params
+    respond_to do |format|
+      # render a turbo_stream so that we can render inputs and forms in separate areas of the page
+      # in case we're nested inside a form
+      format.turbo_stream
+    end
+  end
+
+  # update an exsiting criterion
+  def update
+    @criterion = Refine::Inline::Criterion.new(criterion_params.merge(refine_filter: @refine_filter)) 
+    Refine::Filters::BlueprintEditor
+      .new(@refine_filter.blueprint)
+      .update(params[:id].to_i, criterion: @criterion.to_blueprint_node)
+
+    @error_messages = filter_error_messages(@refine_filter)
+    if @error_messages.none?
+        handle_filter_update(@refine_filter.to_stable_id)
+    else
+      respond_to do |format|
+        format.turbo_stream { render :edit }
+      end
+    end
+  end
+
+  # remove an existing criterion
+  def destroy
+    @criterion = Refine::Inline::Criterion
+      .groups_from_filter(@refine_filter, **criterion_params.slice(:client_id, :stable_id))
+      .flatten
+      .detect { |c| c.position.to_s == params[:id] }
+
+    Refine::Filters::BlueprintEditor
+      .new(@refine_filter.blueprint)
+      .delete(params[:id].to_i)
+
+    handle_filter_update(@refine_filter.to_stable_id)
+  end
+
+  private
+
+  def set_refine_filter
+    @refine_filter ||= Refine::Rails.configuration.stabilizer_classes[:url]
+      .new
+      .from_stable_id(id: criterion_params[:stable_id])
+  end
+
+  def criterion_params
+    params.require(:refine_inline_criterion).permit(
+      :stable_id,
+      :client_id,
+      :condition_id,
+      :position,
+      :conjunction,
+      input_attributes: [
+        :clause,
+        :date1,
+        :date2,
+        :days,
+        :modifier,
+        :selected,
+        :value,
+        :value1,
+        :value2,
+        selected: [],
+        count_refinement_attributes: [
+          :clause,
+          :value1,
+          :value2
+        ]
+      ]
+    )
+  end
+
+  # either directly redirect or emit a `filter-submit-success` event
+  def handle_filter_update stable_id
+    # update_stable_id in url
+    uri = URI(request.referrer)
+    new_query_ar = URI.decode_www_form(String(uri.query))
+    new_query_ar.reject! { |(k, _v)| k == "stable_id" }
+    new_query_ar << ["stable_id", stable_id]
+    uri.query = URI.encode_www_form(new_query_ar)
+
+    respond_to do |format|
+      format.turbo_stream do
+        @refine_stable_id = stable_id
+        @url_for_redirect = uri
+        @refine_client_id = @criterion.client_id
+        render :create
+      end
+      format.html {redirect_to uri.to_s }
+    end
+  end
+
+  def filter_valid?(refine_filter)
+    Refine::Inline::Criterion
+      .groups_from_filter(refine_filter, **criterion_params.slice(:client_id, :stable_id))
+      .flatten
+      .all?(&:valid?)
+  end
+
+  def filter_error_messages(refine_filter)
+    criteria = Refine::Inline::Criterion
+      .groups_from_filter(refine_filter, **criterion_params.slice(:client_id, :stable_id))
+      .flatten
+
+    criteria.each(&:validate!)
+    criteria.flat_map {|c| c.errors.full_messages }
+  end
+end

data/app/controllers/refine/inline/stored_filters_controller.rb

@@ -0,0 +1,84 @@
+class Refine::Inline::StoredFiltersController < ApplicationController
+  layout false
+  before_action :set_refine_filter
+
+
+  def index
+    @criterion = Refine::Inline::Criterion.new(criterion_params)
+    @stored_filters = Refine::StoredFilter.where(filter_type: @refine_filter.type)
+    @stored_filters = instance_exec(@stored_filters, &Refine::Rails.configuration.stored_filter_scope)
+  end
+
+  def find
+    @stored_filter = Refine::StoredFilter.find_by(id: params[:id], filter_type: @refine_filter.type)
+    handle_filter_update @stored_filter.refine_filter.to_stable_id
+  end
+
+  def new
+    @criterion = Refine::Inline::Criterion.new(criterion_params)
+    @stored_filter = Refine::StoredFilter.new(filter_type: @refine_filter.type)
+    respond_to do |format|
+      format.turbo_stream
+    end
+  end
+
+  def create
+    @criterion = Refine::Inline::Criterion.new(criterion_params)
+    @stored_filter = Refine::StoredFilter.new(stored_filter_params.merge(
+        state: @refine_filter.state,
+        filter_type: @refine_filter.type,
+        **instance_exec(&Refine::Rails.configuration.custom_stored_filter_attributes)
+      )
+    )
+
+    if @stored_filter.save
+      handle_filter_update @stored_filter.refine_filter.to_stable_id
+    else
+      respond_to do |format|
+        format.turbo_stream { render :new }
+      end
+    end
+  end
+
+  private
+
+  def set_refine_filter
+    @refine_filter ||= Refine::Rails.configuration.stabilizer_classes[:url]
+      .new
+      .from_stable_id(id: criterion_params[:stable_id])
+  end
+
+  def criterion_params
+    params.require(:refine_inline_criterion).permit(
+      :stable_id,
+      :client_id,
+      :position,
+      :conjunction
+    )
+  end
+
+  def stored_filter_params
+    params.require(:refine_stored_filter).permit(:name)
+  end
+
+  # either directly redirect or emit a `filter-submit-success` event
+  def handle_filter_update stable_id
+    # update_stable_id in url
+    uri = URI(request.referrer)
+    new_query_ar = URI.decode_www_form(String(uri.query))
+    new_query_ar.reject! { |(k, _v)| k == "stable_id" }
+    new_query_ar << ["stable_id", stable_id]
+    uri.query = URI.encode_www_form(new_query_ar)
+
+    respond_to do |format|
+      format.turbo_stream do
+        @refine_stable_id = stable_id
+        @url_for_redirect = uri
+        @refine_client_id = criterion_params[:client_id]
+        @refine_filter = @stored_filter.refine_filter
+        render :find
+      end
+      format.html {redirect_to uri.to_s }
+    end
+  end
+end

data/app/controllers/refine/stored_filters_controller.rb

@@ -0,0 +1,69 @@
+module Refine
+  class StoredFiltersController < ApplicationController
+    layout false
+
+    before_action :set_builder
+
+    def index
+      @stored_filters = StoredFilter.where(filter_type: @refine_filter_builder.filter_class)
+      @stored_filters = instance_exec(@stored_filters, &Refine::Rails.configuration.stored_filter_scope)
+    end
+
+    def find
+      @stored_filter = StoredFilter.find_by(id: params[:id])
+      @refine_filter_builder.stored_filter_id = @stored_filter.id
+
+      # KLUDGE we need a base scope for determining if the filter is valid.
+      # We set initial_queryto model.all because this filter is used just for validation
+      # and is never evaluated.
+      #
+      # This method is a temporary workaround until we clean up input validation and
+      # filter evaluation
+      filter_for_model = @stored_filter.refine_filter
+      model = filter_for_model.model # AR::Base subclass
+      @refine_filter = @stored_filter.refine_filter(initial_query: model.all)
+      @refine_filter_query = Refine::Filters::Query.new(@refine_filter)
+      unless @refine_filter.valid_query?
+        redirect_to refine_stored_filters_path(@refine_filter_builder.to_params),
+          alert: "Sorry, that filter is not valid"
+      end
+    end
+
+    def new
+      @stored_filter = StoredFilter.new(filter_type: @refine_filter_builder.filter_class)
+    end
+
+    def create
+      @refine_filter = @refine_filter_builder.refine_filter
+
+      @stored_filter = StoredFilter.new(name: params[:name], state: @refine_filter.state, filter_type: @refine_filter.type, **instance_exec(&Refine::Rails.configuration.custom_stored_filter_attributes))
+      @refine_filter_query = @refine_filter_builder.query
+
+      if !@refine_filter_query.valid?
+        # replace the filter form with errors
+        render :create
+      elsif !@stored_filter.save
+        # replace the stored filter form
+        render :new, status: :unprocessable_entity
+      else
+        # return to stored filters header and load the filter into the query builder
+        @refine_filter_builder.stored_filter_id = @stored_filter.id
+        render :find
+      end
+    end
+
+    private
+
+    def set_builder
+      builder_params = params.require(:refine_filters_builder).permit(
+        :blueprint_json,
+        :filter_class,
+        :stable_id,
+        :stored_filter_id,
+        :client_id,
+      )
+
+      @refine_filter_builder = Refine::Filters::Builder.new(builder_params)
+    end
+  end
+end

data/app/javascript/controllers/index.js

@@ -0,0 +1,66 @@
+import { identifierForContextKey } from "@hotwired/stimulus-webpack-helpers"
+
+import AddController from './refine/add-controller'
+import InlineConditionsController from './refine/inline-conditions-controller'
+import CriterionFormController from './refine/criterion-form-controller'
+import DefaultsController from './refine/defaults-controller'
+import DeleteController from './refine/delete-controller'
+import FilterPillsController from './refine/filter-pills-controller'
+import PopupController from './refine/popup-controller'
+import SearchFilterController from './refine/search-filter-controller'
+import ServerRefreshController from './refine/server-refresh-controller'
+import StateController from './refine/state-controller'
+import StoredFilterController from './refine/stored-filter-controller'
+import SubmitForm from './refine/submit-form-controller'
+import ToggleController from './refine/toggle-controller'
+import TurboStreamFormController from './refine/turbo-stream-form-controller'
+import TurboStreamLinkController from './refine/turbo-stream-link-controller'
+import UpdateController from './refine/update-controller'
+import DateController from './refine/date-controller'
+
+export const controllerDefinitions = [
+  [AddController, 'refine/add-controller.js'],
+  [InlineConditionsController, './refine/inline-conditions-controller.js'],
+  [CriterionFormController, 'refine/criterion-form-controller.js'],
+  [DefaultsController, 'refine/defaults-controller.js'],
+  [DeleteController, 'refine/delete-controller.js'],
+  [FilterPillsController, 'refine/filter-pills-controller.js'],
+  [PopupController, 'refine/popup-controller.js'],
+  [SearchFilterController, 'refine/search-filter-controller.js'],
+  [ServerRefreshController, 'refine/server-refresh-controller.js'],
+  [StateController, 'refine/state-controller.js'],
+  [StoredFilterController, 'refine/stored-filter-controller.js'],
+  [SubmitForm, 'refine/submit-form-controller.js'],
+  [ToggleController, 'refine/toggle-controller.js'],
+  [TurboStreamFormController, 'refine/turbo-stream-form-controller.js'],
+  [TurboStreamLinkController, 'refine/turbo-stream-link-controller.js'],
+  [UpdateController, 'refine/update-controller.js'],
+  [DateController, 'refine/date-controller.js']
+].map(function(d) {
+  const key = d[1]
+  const controller = d[0]
+  return {
+    identifier: identifierForContextKey(key),
+    controllerConstructor: controller
+  }
+})
+
+export {
+  AddController,
+  InlineConditionsController,
+  CriterionFormController,
+  DefaultsController,
+  DeleteController,
+  FilterPillsController,
+  PopupController,
+  SearchFilterController,
+  ServerRefreshController,
+  StateController,
+  StoredFilterController,
+  SubmitForm,
+  ToggleController,
+  TurboStreamFormController,
+  TurboStreamLinkController,
+  UpdateController,
+  DateController
+}

data/app/javascript/controllers/refine/add-controller.js

@@ -0,0 +1,42 @@
+import ServerRefreshController from './server-refresh-controller'
+import { FetchRequest } from '@rails/request.js'
+
+export default class extends ServerRefreshController {
+  static values = {
+    previousCriterionId: Number,
+  }
+
+  async criterion() {
+    const isValid = await this.validateBlueprint()
+    if (isValid) {
+      this.state.addCriterion(this.previousCriterionIdValue)
+    }
+    this.refreshFromServer({includeErrors: !isValid})
+  }
+
+  async group() {
+    const isValid = await this.validateBlueprint()
+    if (isValid) {
+      this.state.addGroup()
+    }
+    this.refreshFromServer({includeErrors: !isValid})
+  }
+
+  async validateBlueprint(blueprint) {
+    const { state } = this
+
+    const request = new FetchRequest(
+      "GET",
+      this.state.validateBlueprintUrlValue,
+      {
+        query: {
+          "refine_filters_builder[filter_class]": this.state.filterName,
+          "refine_filters_builder[blueprint_json]": JSON.stringify(this.state.blueprint),
+          "refine_filters_builder[client_id]": this.state.clientIdValue
+        }
+      }
+    )
+    const response = await request.perform()
+    return response.ok
+  }
+}

data/app/javascript/controllers/refine/criterion-form-controller.js

@@ -0,0 +1,31 @@
+import { Controller } from "@hotwired/stimulus"
+import { FetchRequest } from '@rails/request.js'
+
+/*
+  This controller handles criteria forms
+  (refine/inline/criteria/new|edit)
+*/
+export default class extends Controller {
+  static values = {
+    url: String,
+    turboFrame: String,
+    method: { type: String, default: "POST" }
+  }
+
+  refresh(_event) {
+    // update the url with params from the form
+    const formData = new FormData(this.element)
+    const url = new URL(this.urlValue)
+
+    for (const [name, value] of formData.entries()) {
+      console.log(name, value)
+      url.searchParams.set(name, value)
+    }
+
+    // navigate the modal to refresh the form
+    window.Turbo.visit(url.toString(), {frame: this.turboFrameValue})
+  }
+
+
+
+}

data/app/javascript/controllers/refine/date-controller.js

@@ -0,0 +1,113 @@
+import { Controller } from "@hotwired/stimulus"
+import moment from 'moment'
+require('daterangepicker/daterangepicker.css')
+
+// requires jQuery, moment, might want to consider a vanilla JS alternative
+import $ from 'jquery' // ensure jquery is loaded before daterangepicker
+import 'daterangepicker'
+
+export default class extends Controller {
+  static targets = [
+    'field',
+    'hiddenField',
+    'clearButton',
+  ]
+
+  static values = {
+    includeTime: Boolean,
+    futureOnly: Boolean,
+    drops: String,
+    inline: Boolean,
+    dateFormat: String,
+    timeFormat: String,
+    isAmPm: Boolean,
+    locale: { type: String, default: 'en' },
+    datetimeFormat: { type: String, default:  'MM/DD/YYYY h:mm A' },
+    pickerLocale: { type: Object, default: {} },
+  }
+
+  connect() {
+    this.initPluginInstance()
+  }
+
+  disconnect() {
+    this.teardownPluginInstance()
+  }
+
+  clearDate(event) {
+    // don't submit the form, unless it originated from the cancel/clear button
+    event.preventDefault()
+
+    window.$(this.fieldTarget).val('')
+
+    this.dispatch('value-cleared')
+  }
+
+  applyDateToField(event, picker) {
+    const format = this.includeTimeValue ? this.timeFormatValue : this.dateFormatValue
+
+    const momentVal = picker
+      ? moment(picker.startDate.toISOString())
+      : moment(this.fieldTarget.value, 'YYYY-MM-DDTHH:mm').format('YYYY-MM-DDTHH:mm')
+    const displayVal = momentVal.format(format)
+    const dataVal = this.includeTimeValue ? momentVal.toISOString(true) : momentVal.format('YYYY-MM-DD')
+
+    this.fieldTarget.value = displayVal
+    this.hiddenFieldTarget.value = dataVal
+    // bubble up a change event when the input is updated for other listeners
+    window.$(this.fieldTarget).trigger('change', picker)
+
+    // emit native change event
+    this.hiddenFieldTarget.dispatchEvent(new Event('change', { detail: picker, bubbles: true }))
+  }
+
+  initPluginInstance() {
+    const localeValues = this.pickerLocaleValue
+    const isAmPm = this.isAmPmValue
+    localeValues['format'] = this.includeTimeValue ? this.timeFormatValue : this.dateFormatValue
+
+    window.$(this.fieldTarget).daterangepicker({
+      singleDatePicker: true,
+      timePicker: this.includeTimeValue,
+      timePickerIncrement: 5,
+      autoUpdateInput: false,
+      autoApply: true,
+      minDate: this.futureOnlyValue ? new Date() : false,
+      locale: localeValues,
+      parentEl: $(this.element),
+      drops: this.dropsValue ? this.dropsValue : 'down',
+      timePicker24Hour: !isAmPm,
+    })
+
+    window.$(this.fieldTarget).on('apply.daterangepicker', this.applyDateToField.bind(this))
+    window.$(this.fieldTarget).on('cancel.daterangepicker', this.clearDate.bind(this))
+    window.$(this.fieldTarget).on('showCalendar.daterangepicker', this.showCalendar.bind(this))
+
+    this.pluginMainEl = this.fieldTarget
+    this.plugin = $(this.pluginMainEl).data('daterangepicker') // weird
+
+    if (this.inlineValue) {
+      this.element.classList.add('date-input--inline')
+    }
+
+  }
+    
+  teardownPluginInstance() {
+    if (this.plugin === undefined) {
+      return
+    }
+
+    $(this.pluginMainEl).off('apply.daterangepicker')
+    $(this.pluginMainEl).off('cancel.daterangepicker')
+    $(this.pluginMainEl).off('showCalendar.daterangepicker')
+
+    // revert to original markup, remove any event listeners
+    this.plugin.remove()
+
+  }
+
+  showCalendar() {
+    this.dispatch('show-calendar')
+  }
+
+}