mensa 0.3.4 → 0.5.0

data/app/helpers/mensa/application_helper.rb

@@ -1,7 +1,7 @@
 module Mensa
   module ApplicationHelper
-    def table(name, config = {}, **options)
-      component = ::Mensa::Table::Component.new(name, config, **options)
+    def table(name, params: {}, **options)
+      component = ::Mensa::Table::Component.new(name, params: params, **options)
       component.original_view_context = self
       render(component)
     end

data/app/jobs/mensa/export_job.rb

@@ -23,6 +23,7 @@ module Mensa
 
       data, filename, content_type = generate(table, export)
 
+      export.asset.purge if export.asset.attached?
       export.asset.attach(io: StringIO.new(data), filename: filename, content_type: content_type)
       finalize(export, status: "completed", filename: filename)
 
@@ -94,6 +95,9 @@ module Mensa
     def finalize(export, status:, filename: nil)
       attributes = {status: status}
       attributes[:filename] = filename if filename
+
+      attributes[:last_repeat_run_at] = Time.current if status == "completed" && export.repeat.present?
+
       export.update(attributes)
       # Refresh the export button badge (download count) and the downloads list
       # inside the export dialog for everyone viewing this table.

data/app/jobs/mensa/recurring_exports_job.rb

@@ -0,0 +1,17 @@
+module Mensa
+  # Sweeps recurring exports and re-enqueues any whose next scheduled run is due.
+  # This job is intended to be invoked by a daily cron entry or scheduler.
+  class RecurringExportsJob < ApplicationJob
+    queue_as :default
+
+    def perform(reference_time = Time.current)
+      reference_time = reference_time.in_time_zone if reference_time.respond_to?(:in_time_zone)
+
+      Mensa::Export.repeating.find_each do |export|
+        next unless export.repeat_due?(reference_time)
+
+        Mensa::ExportJob.perform_later(export)
+      end
+    end
+  end
+end

data/app/models/mensa/export.rb

@@ -7,17 +7,21 @@ module Mensa
     STATUSES = %w[pending processing completed failed].freeze
     FORMATS = %w[csv_excel plain_csv].freeze
     SCOPES = %w[all current_page].freeze
+    REPEATS = ["", "daily", "weekly", "monthly", "quarterly", "bi-yearly", "yearly"].freeze
 
     belongs_to :user, optional: true
     has_one_attached :asset
 
     validates :table_name, presence: true
     validates :status, inclusion: {in: STATUSES}
+    validates :repeat, inclusion: {in: REPEATS}
 
     scope :for_table, ->(table_name) { where(table_name: table_name.to_s) }
     scope :for_user, ->(user) { where(user_id: user.respond_to?(:id) ? user&.id : user) }
     scope :completed, -> { where(status: "completed") }
     scope :recent, -> { order(created_at: :desc) }
+    scope :repeating, -> { where.not(repeat: [nil, ""]) }
+    scope :with_downloadable_asset, -> { completed.joins(:asset_attachment).distinct }
 
     def completed?
       status == "completed"
@@ -35,15 +39,63 @@ module Mensa
       status == "pending"
     end
 
+    def next_repeat_run_at(from: nil)
+      return if repeat.blank?
+
+      anchor = from || last_repeat_run_at || created_at
+
+      case repeat
+      when "daily"
+        anchor + 1.day
+      when "weekly"
+        anchor + 1.week
+      when "monthly"
+        anchor.advance(months: 1)
+      when "quarterly"
+        anchor.advance(months: 3)
+      when "bi-yearly"
+        anchor.advance(months: 6)
+      when "yearly"
+        anchor.advance(years: 1)
+      end
+    end
+
+    def repeat_due?(reference_time = Time.current)
+      return false if repeat.blank? || pending? || processing?
+
+      next_run_at = next_repeat_run_at
+      next_run_at.present? && next_run_at <= reference_time
+    end
+
+    def repeating?
+      repeat.present?
+    end
+
+    def repeat_label
+      return if repeat.blank?
+
+      I18n.t(
+        "mensa.exports.repeats_with_interval",
+        default: "Repeats %{interval}",
+        interval: repeat_interval_label
+      )
+    end
+
+    def repeat_interval_label
+      return if repeat.blank?
+
+      I18n.t("mensa.exports.repeat_intervals.#{repeat}", default: repeat)
+    end
+
     # True once the asset is ready to be downloaded by the user.
     def downloadable?
       completed? && asset.attached?
     end
 
-    # Number of completed (downloadable) exports for a table/user combination.
+    # Number of currently-downloadable exports for a table/user combination.
     # This is the number rendered in the export button badge.
     def self.completed_count(table_name, user)
-      for_table(table_name).for_user(user).completed.count
+      for_table(table_name).for_user(user).with_downloadable_asset.count
     end
 
     # A stable, page-independent key identifying the exports of a table/user

data/app/tables/mensa/base.rb

@@ -8,8 +8,8 @@ module Mensa
 
     attr_writer :original_view_context
     attr_accessor :component, :name, :table_view, :request
-    attr_reader :params
 
+    config_reader :params
     config_reader :model
     config_reader :scope
     config_reader :link, call: false
@@ -22,12 +22,12 @@ module Mensa
     config_reader :export_with_password?
 
     def initialize(config = {})
-      @params = config.to_h.deep_symbolize_keys
-      @config = self.class.definition.merge(@params || {})
+      normalized_config = config.to_h.deep_symbolize_keys
+      @config = self.class.definition.merge(normalized_config)
+      @params = (@config[:params].presence || {}).deep_symbolize_keys
+      @config[:params] = @params
 
-      ensure_internal_columns_for_joined_associations
-
-      params[:hidden_columns]&.each do |column_name|
+      current_hidden_columns&.each do |column_name|
         c = columns.find { |c| c.name == column_name.to_sym }
         c.config[:visible] = false
       end
@@ -48,12 +48,17 @@ module Mensa
 
     # Returns all columns
     def columns
+      ensure_internal_columns_for_joined_associations
       @columns ||= column_order.map { |column_name| Mensa::Column.new(column_name, config: config.dig(:columns, column_name), table: self) }
     end
 
     # Returns a column by name
     # @param [String] name
     def column(name)
+      found_column = columns.find { |c| c.name == name.to_sym }
+      return found_column if found_column || @internal_columns_ensured
+
+      @columns = nil
       columns.find { |c| c.name == name.to_sym }
     end
 
@@ -117,16 +122,19 @@ module Mensa
     end
 
     # Returns the current path with configuration
-    def path(order: {}, turbo_frame_id: nil, table_view_id: params[:table_view_id], column_order: params[:column_order], hidden_columns: params[:hidden_columns])
+    def path(order: {}, turbo_frame_id: current_turbo_frame_id, table_view_id: current_table_view_id, column_order: current_column_order, hidden_columns: current_hidden_columns, user_params: nil)
       # FIXME: if someone doesn't use as: :mensa in the routes, it breaks
-      original_view_context.mensa.table_path(
-        name,
+      path = original_view_context.mensa.table_path(name)
+      query = {
+        params: user_params || params,
         order: order_hash(order),
         turbo_frame_id: turbo_frame_id,
         table_view_id: table_view_id,
         column_order: column_order,
         hidden_columns: hidden_columns
-      )
+      }.compact.to_query
+
+      query.present? ? "#{path}?#{query}" : path
     end
 
     def all_views
@@ -146,21 +154,53 @@ module Mensa
     def table_id
       return @table_id if @table_id
 
-      @table_id = params[:turbo_frame_id] || "#{name.to_s.gsub("/", "__")}-#{SecureRandom.base36}"
+      @table_id = current_turbo_frame_id || "#{name.to_s.gsub("/", "__")}-#{SecureRandom.base36}"
     end
 
     def original_view_context
       @original_view_context || component.original_view_context
     end
 
+    def current_query
+      config[:query]
+    end
+
+    def current_order
+      config[:order]
+    end
+
+    def current_order_provided?
+      config.key?(:order)
+    end
+
+    def current_table_view_id
+      config[:table_view_id]
+    end
+
+    def current_column_order
+      config[:column_order]
+    end
+
+    def current_hidden_columns
+      config[:hidden_columns]
+    end
+
+    def current_turbo_frame_id
+      config[:turbo_frame_id]
+    end
+
     private
 
     def ensure_internal_columns_for_joined_associations
+      return if @internal_columns_ensured
+
       config[:columns] ||= {}
 
       auto_internal_column_names.each do |column_name|
-        config[:columns][column_name] ||= {internal: true}
+        config[:columns][column_name] ||= {internal: true, filter: false}
       end
+
+      @internal_columns_ensured = true
     end
 
     def auto_internal_column_names

data/app/tables/mensa/column.rb

@@ -22,7 +22,7 @@ module Mensa
 
     def sort_direction
       value = table.config.dig(:order, name)
-      value.present? ? value.to_sym : nil
+      value.presence&.to_sym
     end
 
     def next_sort_direction
@@ -41,12 +41,22 @@ module Mensa
       @attribute = if config[:attribute].present?
         "#{config[:attribute]} AS #{name}"
       elsif table.model.column_names.include? name.to_s
-        name.to_s
+        "#{table.model.table_name}.#{name}"
+      end
+    end
+
+    def raw_attribute
+      return @raw_attribute if @raw_attribute
+
+      @raw_attribute = if config[:attribute].present?
+        config[:attribute]
+      elsif table.model.column_names.include? name.to_s
+        "#{table.model.table_name}.#{name}"
       end
     end
 
     def active_record_column
-      @active_record_column ||= table.model&.columns&.find { it.name == name.to_s }
+      @active_record_column ||= table.model&.columns&.find { |column| column.name == name.to_s }
     end
 
     def active_record_column_type
@@ -61,15 +71,15 @@ module Mensa
       return @attribute_for_condition if @attribute_for_condition
 
       @attribute_for_condition = if config[:attribute].present?
-        config[:attribute]
+        raw_attribute
       elsif table.model.column_names.include? name.to_s
-        name.to_s
+        "#{table.model.table_name}.#{name}"
       end
     end
 
     # Returns true if the column supports filtering
     def filter?
-      config.key?(:filter)
+      config[:filter] != false
     end
 
     def filter

data/app/tables/mensa/config/dsl_logic.rb

@@ -59,8 +59,8 @@ module Mensa::Config
       # by calling option :render, dsl: Mensa::RenderDsl
       #
       def dsl_option(option_name, klass)
-        define_method(option_name) do |name = nil, &block|
-          config[option_name.to_sym] = block && klass.new(name, &block).config
+        define_method(option_name) do |value = nil, &block|
+          config[option_name.to_sym] = block ? klass.new(value, &block).config : value
         end
       end
 

data/app/tables/mensa/config/table_dsl.rb

@@ -48,6 +48,7 @@ module Mensa::Config
   class TableDsl
     include DslLogic
 
+    option :params, default: {}
     option :model, default: -> {
       begin
         self.class.name.demodulize.to_s.classify.gsub("Table", "").singularize.constantize
@@ -88,6 +89,7 @@ module Mensa::Config
     def internal(name, &block)
       column(name) do
         internal true
+        filter false
         instance_exec(&block) if block
       end
     end

data/app/tables/mensa/filter.rb

@@ -24,7 +24,8 @@ module Mensa
           [:gteq, I18n.t("mensa.operators.gteq"), true],
           [:lt, I18n.t("mensa.operators.lt"), true],
           [:lteq, I18n.t("mensa.operators.lteq"), true],
-          [:is_current, I18n.t("mensa.operators.is_current"), false]
+          [:is_current, I18n.t("mensa.operators.is_current"), false],
+          [:is_empty, I18n.t("mensa.operators.is_empty"), false]
         ].freeze
       end
     end
@@ -69,6 +70,12 @@ module Mensa
         record_scope.instance_exec(normalize(value), &scope)
       else
         case operator
+        when :is_empty
+          if column.type == :string
+            record_scope.where("#{column.attribute_for_condition} IS NULL OR #{column.attribute_for_condition} = ''")
+          else
+            record_scope.where("#{column.attribute_for_condition} IS NULL")
+          end
         when :is_current
           record_scope.where("#{column.attribute_for_condition} = ?", Current.send(column.name))
         when :matches

data/app/tables/mensa/scope.rb

@@ -4,6 +4,7 @@ module Mensa
   # scope -> filtered_scope -> ordered_scope -> selected_scope ->
   module Scope
     extend ActiveSupport::Concern
+    include Search
 
     included do
     end
@@ -13,15 +14,7 @@ module Mensa
       return @filtered_scope if @filtered_scope
 
       @filtered_scope = scope
-      # See https://github.com/textacular/textacular
-      # This has problems - not all table fields are searched
-      if params[:query].present?
-        @filtered_scope = if Mensa.config.search == :fuzzy
-          @filtered_scope.fuzzy_search(params[:query])
-        else
-          @filtered_scope.basic_search(params[:query])
-        end
-      end
+      @filtered_scope = search(@filtered_scope, current_query) if current_query.present?
 
       # Use inject
       active_filters.each do |filter|
@@ -36,7 +29,13 @@ module Mensa
       return @ordered_scope if @ordered_scope
 
       @ordered_scope = filtered_scope
-      @ordered_scope = @ordered_scope.reorder(effective_order)
+      @ordered_scope = if effective_order.present?
+        @ordered_scope.reorder(effective_order)
+      elsif search_order_clause.present?
+        @ordered_scope.reorder(Arel.sql(search_order_clause))
+      else
+        @ordered_scope.reorder(nil)
+      end
 
       @ordered_scope
     end
@@ -45,6 +44,8 @@ module Mensa
     def selected_scope
       return @selected_scope if @selected_scope
 
+      ensure_internal_columns_for_joined_associations
+
       @selected_scope = ordered_scope
       @selected_scope = @selected_scope.select([:id] + columns.filter_map(&:attribute))
 
@@ -73,16 +74,16 @@ module Mensa
     # (even with blank values), use only those — blank means "explicitly no sort".
     # Falls back to the view/config default only when no order params were sent.
     def effective_order
-      result = params.key?(:order) ? (params[:order] || {}) : (config[:order] || {})
+      result = current_order_provided? ? (current_order || {}) : (config[:order] || {})
       result = result.symbolize_keys.compact_blank.transform_values(&:to_sym)
-      result.transform_keys { column(_1).attribute_for_condition }
+      result.transform_keys { |column_name| column(column_name).attribute_for_condition }
     end
 
     # Builds an order hash for URL generation. Merges current order with overrides;
     # nil values become "" so they appear in the URL as order[col]= (which tells
     # the server the user explicitly cleared that column's sort direction).
     def order_hash(new_params = {})
-      base = params[:order]&.symbolize_keys || config[:order]&.symbolize_keys || {}
+      base = current_order&.symbolize_keys || config[:order]&.symbolize_keys || {}
       merged = base.merge(new_params.symbolize_keys)
       merged.transform_values { |v| v.nil? ? "" : v.to_sym }
     end

data/app/tables/mensa/search.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Mensa
+  module Search
+    extend ActiveSupport::Concern
+
+    private
+
+    def search(record_scope, query)
+      return record_scope if query.blank?
+      return record_scope unless record_scope.is_a?(ActiveRecord::Relation)
+
+      searchable_attributes = columns.filter_map(&:attribute_for_condition).uniq
+      return record_scope if searchable_attributes.empty?
+
+      @search_order_clause = nil
+
+      fuzzy_search?(record_scope) ? fuzzy_search(record_scope, searchable_attributes, query.to_s) : basic_search(record_scope, searchable_attributes, query.to_s)
+    end
+
+    def basic_search(record_scope, searchable_attributes, query)
+      sanitized_query = ActiveRecord::Base.sanitize_sql_like(query)
+      conditions = searchable_attributes.map do |attribute|
+        "CAST((#{attribute}) AS text) ILIKE :term"
+      end.join(" OR ")
+
+      record_scope.where(conditions, term: "%#{sanitized_query}%")
+    end
+
+    def fuzzy_search(record_scope, searchable_attributes, query)
+      sanitized_query = ActiveRecord::Base.sanitize_sql_like(query)
+      compare_quoted = record_scope.model.connection.quote(query)
+      text_expression = searchable_text_expression(searchable_attributes)
+      score_sql = "similarity(#{text_expression}, #{compare_quoted})"
+
+      @search_order_clause = "#{score_sql} DESC"
+
+      record_scope
+        .select(Arel.sql("#{score_sql} AS mensa_search_score"))
+        .where("#{text_expression} % :query OR #{text_expression} ILIKE :term", query: query, term: "%#{sanitized_query}%")
+        .order(Arel.sql(@search_order_clause))
+    end
+
+    def searchable_text_expression(searchable_attributes)
+      fields = searchable_attributes.map do |attribute|
+        "COALESCE(CAST((#{attribute}) AS text), '')"
+      end.join(", ")
+
+      "CONCAT_WS(' ', #{fields})"
+    end
+
+    def search_order_clause
+      @search_order_clause
+    end
+
+    def fuzzy_search?(record_scope)
+      Mensa.config.search == :fuzzy && pg_trgm_enabled?(record_scope)
+    end
+
+    def pg_trgm_enabled?(record_scope)
+      connection = record_scope.model.connection
+      return false unless connection.adapter_name.to_s.downcase.include?("postgres")
+      return connection.extension_enabled?("pg_trgm") if connection.respond_to?(:extension_enabled?)
+
+      connection.select_value("SELECT 1 FROM pg_extension WHERE extname = 'pg_trgm' LIMIT 1").present?
+    rescue
+      false
+    end
+  end
+end

data/app/views/mensa/exports/_dialog.html.erb

@@ -37,6 +37,29 @@
           </label>
         </fieldset>
 
+        <fieldset class="mensa-table__export-dialog__fieldset">
+          <legend class="mensa-table__export-dialog__section-title"><%= t("mensa.exports.repeat_section", default: "Repeat") %></legend>
+          <label class="mensa-table__export-dialog__option">
+            <input type="radio" name="repeat_mode" value="once" checked data-action="change->mensa-table#toggleExportRepeat">
+            <span><%= t("mensa.exports.repeat_once", default: "Only once") %></span>
+          </label>
+          <label class="mensa-table__export-dialog__option">
+            <input type="radio" name="repeat_mode" value="repeating" data-action="change->mensa-table#toggleExportRepeat">
+            <span><%= t("mensa.exports.repeat_repeating", default: "Repeating") %></span>
+          </label>
+
+          <div class="mensa-table__export-dialog__repeat-options" hidden data-mensa-table-repeat-options>
+            <select name="repeat" class="mensa-table__export-dialog__select">
+              <option value="daily"><%= t("mensa.exports.repeat_intervals.daily", default: "daily") %></option>
+              <option value="weekly"><%= t("mensa.exports.repeat_intervals.weekly", default: "weekly") %></option>
+              <option value="monthly"><%= t("mensa.exports.repeat_intervals.monthly", default: "monthly") %></option>
+              <option value="quarterly"><%= t("mensa.exports.repeat_intervals.quarterly", default: "quarterly") %></option>
+              <option value="bi-yearly"><%= t("mensa.exports.repeat_intervals.bi-yearly", default: "bi-yearly") %></option>
+              <option value="yearly"><%= t("mensa.exports.repeat_intervals.yearly", default: "yearly") %></option>
+            </select>
+          </div>
+        </fieldset>
+
         <div class="mensa-table__export-dialog__actions">
           <button class="mensa-table__export-dialog__button mensa-table__export-dialog__button--secondary" type="button" data-action="mensa-table#cancelExport">
             <%= t("mensa.exports.cancel", default: "Cancel") %>

data/app/views/mensa/exports/_list.html.erb

@@ -6,8 +6,19 @@
     <ul class="mensa-table__export-dialog__list">
       <% exports.each do |export| %>
         <li class="mensa-table__export-dialog__item">
+          <%= button_to mensa.table_export_path(export.table_name, export),
+            method: :delete,
+            class: "mensa-table__export-dialog__delete",
+            form_class: "mensa-table__export-dialog__delete-form",
+            aria: {label: t("mensa.exports.delete", default: "Delete export") } do %>
+            <i class="fa-solid fa-trash"></i>
+          <% end %>
+
           <div class="mensa-table__export-dialog__item-info">
             <span class="mensa-table__export-dialog__item-name"><%= export.filename.presence || t("mensa.exports.item_name", default: "%{table} export", table: export.table_name.to_s.humanize) %></span>
+            <% if export.repeating? %>
+              <span class="mensa-table__export-dialog__item-repeat"><%= export.repeat_label %></span>
+            <% end %>
             <span class="mensa-table__export-dialog__item-meta"><%= export.created_at.strftime("%Y-%m-%d %H:%M") %></span>
           </div>
           <div class="mensa-table__export-dialog__item-action">
@@ -18,6 +29,8 @@
               <% end %>
             <% elsif export.failed? %>
               <span class="mensa-table__export-dialog__status mensa-table__export-dialog__status--failed"><%= t("mensa.exports.failed", default: "Failed") %></span>
+            <% elsif export.completed? %>
+              <span class="mensa-table__export-dialog__status mensa-table__export-dialog__status--pending"><%= t("mensa.exports.waiting", default: "Waiting") %></span>
             <% else %>
               <span class="mensa-table__export-dialog__status mensa-table__export-dialog__status--pending">
                 <i class="fa-solid fa-spinner fa-spin"></i>

data/app/views/mensa/tables/show.html.erb

@@ -1,5 +1,3 @@
-Test
-<button class="text-xs">Esc</button>
 <turbo-frame id="<%= @table.table_id %>" target="_top">
   <%= render Mensa::View::Component.new(@table) %>
 </turbo-frame>

data/app/views/mensa/tables/standard_error.html.erb

@@ -0,0 +1,9 @@
+<turbo-frame id="<%= @frame_id %>">
+  <div class="mensa-empty-state">
+    <div class="mensa-empty-state__icon">
+      <i class="fa-solid fa-circle-exclamation"></i>
+    </div>
+    <h3 class="mensa-empty-state__title">Could not load table</h3>
+    <p class="mensa-empty-state__subtitle"><%= @error_message %></p>
+  </div>
+</turbo-frame>

data/config/locales/en.yml

@@ -1,5 +1,10 @@
 en:
   mensa:
+    actions: Actions
+    save: Save
+    update_view: Update view
+    save_view: Save as new view
+    save_as_new_view: Save as new view
     operators:
       is: is
       isnt: isn't
@@ -10,7 +15,9 @@ en:
       lt: less than
       gteq: greater than or equal to
       lteq: less than or equal to
+      is_empty: is empty
     add_filter:
+      add: Add filter
       component:
         add_filter: Add filter
     filter_pill_list:
@@ -19,6 +26,7 @@ en:
         search_only: Search
     search:
       component:
+        search: Search and filter
         search_in: Search in %{view}
         cancel: Cancel
         save: Save
@@ -34,8 +42,22 @@ en:
       available_downloads: Available downloads
       empty: You have no downloads yet. Create one below.
       item_name: "%{table} export"
+      repeats_with_interval: "Repeats %{interval}"
+      repeat_section: Repeat
+      repeat: Repeat
+      repeat_once: "Only once"
+      repeat_repeating: Repeating
+      repeat_intervals:
+        daily: daily
+        weekly: weekly
+        monthly: monthly
+        quarterly: quarterly
+        bi-yearly: bi-yearly
+        yearly: yearly
       download: Download
+      delete: Delete export
       processing: Preparing…
+      waiting: Waiting
       failed: Failed
       new_export: New export
       scope_all: All records (matching current filters)

data/config/locales/nl.yml

@@ -1,5 +1,10 @@
 nl:
   mensa:
+    actions: Acties
+    save: Bewaar
+    update_view: Bewaar weergave
+    save_view: Bewaar als nieuwe weergave
+    save_as_new_view: Bewaar als nieuwe weergave
     operators:
       is: is
       isnt: is niet
@@ -10,7 +15,9 @@ nl:
       lt: kleiner dan
       gteq: groter dan of gelijk aan
       lteq: kleiner dan of gelijk aan
+      is_empty: is leeg
     add_filter:
+      add: Filter toevoegen
       component:
         add_filter: Filter toevoegen
     filter_pill_list:
@@ -35,8 +42,22 @@ nl:
       available_downloads: Beschikbare downloads
       empty: Je hebt nog geen downloads. Maak er hieronder een aan.
       item_name: "%{table} export"
+      repeats_with_interval: "Herhaalt %{interval}"
+      repeat_section: Herhalen
+      repeat: Herhalen
+      repeat_once: "Eenmalig"
+      repeat_repeating: Herhalend
+      repeat_intervals:
+        daily: dagelijks
+        weekly: wekelijks
+        monthly: maandelijks
+        quarterly: per kwartaal
+        bi-yearly: halfjaarlijks
+        yearly: jaarlijks
       download: Downloaden
+      delete: Export verwijderen
       processing: Bezig…
+      waiting: Wachtend
       failed: Mislukt
       new_export: Nieuwe export
       scope_all: Alle records (volgens huidige filters)