mensa 0.2.4 → 0.2.6

data/app/models/mensa/export.rb

@@ -0,0 +1,93 @@
+module Mensa
+  # An export request for a Mensa table. Each export captures the table it was
+  # generated for, the view (if any), the requesting user and the request
+  # configuration (filters/query/order/page) needed to rebuild the data. Once
+  # processed by Mensa::ExportJob the generated CSV is stored in +asset+.
+  class Export < ApplicationRecord
+    STATUSES = %w[pending processing completed failed].freeze
+    FORMATS = %w[csv_excel plain_csv].freeze
+    SCOPES = %w[all current_page].freeze
+
+    belongs_to :user, optional: true
+    has_one_attached :asset
+
+    validates :table_name, presence: true
+    validates :status, inclusion: {in: STATUSES}
+
+    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) }
+
+    def completed?
+      status == "completed"
+    end
+
+    def failed?
+      status == "failed"
+    end
+
+    def processing?
+      status == "processing"
+    end
+
+    def pending?
+      status == "pending"
+    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.
+    # 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
+    end
+
+    # A stable, page-independent key identifying the exports of a table/user
+    # combination, used for Turbo stream names and DOM ids so background jobs
+    # can target them after completion.
+    def self.token(table_name, user)
+      user_key = user.respond_to?(:id) ? user&.id : user
+      [table_name.to_s, user_key || "anonymous"].join("-").parameterize
+    end
+
+    def self.stream_name(table_name, user)
+      "mensa-exports-#{token(table_name, user)}"
+    end
+
+    def self.badge_dom_id(table_name, user)
+      "mensa-export-badge-#{token(table_name, user)}"
+    end
+
+    def self.list_dom_id(table_name, user)
+      "mensa-export-list-#{token(table_name, user)}"
+    end
+
+    # Re-renders the export button badge and downloads list for everyone
+    # subscribed to this table/user's export stream. Best-effort: a missing
+    # Action Cable backend (or other broadcast failure) must never break the
+    # caller (job completion, download cleanup, ...).
+    def self.broadcast_refresh(table_name, user)
+      stream = stream_name(table_name, user)
+
+      Turbo::StreamsChannel.broadcast_replace_to(
+        stream,
+        target: badge_dom_id(table_name, user),
+        partial: "mensa/exports/badge",
+        locals: {table_name: table_name, user: user}
+      )
+
+      Turbo::StreamsChannel.broadcast_replace_to(
+        stream,
+        target: list_dom_id(table_name, user),
+        partial: "mensa/exports/list",
+        locals: {table_name: table_name, user: user, exports: for_table(table_name).for_user(user).recent}
+      )
+    rescue => e
+      Mensa.config.logger&.warn("Mensa::Export broadcast failed: #{e.class}: #{e.message}")
+    end
+  end
+end

data/app/tables/mensa/action.rb

@@ -11,7 +11,9 @@ module Mensa
   class Action
     include ConfigReaders
 
-    attr_reader :name, :table, :config
+    defined_by Mensa::Config::ActionDsl
+
+    attr_reader :name, :table
 
     def initialize(name, config:, table:)
       @name = name

data/app/tables/mensa/base.rb

@@ -2,20 +2,21 @@ module Mensa
   class Base
     include Pagy::Method
     include ConfigReaders
+
+    defined_by Mensa::Config::TableDsl
     include Scope
 
     attr_writer :original_view_context
     attr_accessor :component, :name, :table_view, :request
-    attr_reader :config, :params
+    attr_reader :params
 
     config_reader :model
+    config_reader :scope
     config_reader :link, call: false
     config_reader :supports_views?
     config_reader :supports_custom_views?
     config_reader :supports_filters?
-    config_reader :view_condensed?
-    config_reader :view_condensed_toggle?
-    config_reader :view_columns_sorting?
+    config_reader :view_columns_ordering?
     config_reader :show_header?
     config_reader :exportable?
     config_reader :export_with_password?
@@ -23,10 +24,26 @@ module Mensa
     def initialize(config = {})
       @params = config.to_h.deep_symbolize_keys
       @config = self.class.definition.merge(@params || {})
+
+      ensure_internal_columns_for_joined_associations
+
+      params[:hidden_columns]&.each do |column_name|
+        c = columns.find { |c| c.name == column_name.to_sym }
+        c.config[:visible] = false
+      end
     end
 
     def column_order
-      config[:column_order] || config[:columns]&.keys
+      order = config[:column_order].presence || config[:columns]&.keys
+      order = order&.map(&:to_sym)
+      return order if order.nil?
+
+      # Internal columns are never shown in the column customizer UI, so they
+      # are absent from any URL-supplied column_order. Always append them so
+      # that columns and selected_scope include their attributes.
+      all_keys = (config[:columns]&.keys || []).map(&:to_sym)
+      internal_keys = all_keys.select { |key| config.dig(:columns, key, :internal) }
+      (order | internal_keys)
     end
 
     # Returns all columns
@@ -40,9 +57,15 @@ module Mensa
       columns.find { |c| c.name == name.to_sym }
     end
 
-    # Returns the columns to be displayed
+    # Returns the columns to be displayed, ordered by column_order.
     def display_columns
-      @display_columns ||= columns.select(&:visible?).reject(&:internal?)
+      @display_columns ||= begin
+        order = column_order || []
+        columns
+          .select(&:visible?)
+          .reject(&:internal?)
+          .sort_by { |col| order.index(col.name) || Float::INFINITY }
+      end
     end
 
     # Returns the rows to be displayed
@@ -55,8 +78,8 @@ module Mensa
     end
 
     def system_views
-      [Mensa::SystemView.new(:all, config: {name: I18n.t("mensa.views.all")}, table: self)] +
-        (config[:views] || {}).keys.map { |view_name| Mensa::SystemView.new(view_name, config: config.dig(:views, view_name), table: self) }
+      views = config[:views]&.key?(:default) ? [] : [Mensa::SystemView.new(:default, config: {name: I18n.t("mensa.views.default")}, table: self)]
+      views + (config[:views] || {}).keys.map { |view_name| Mensa::SystemView.new(view_name, config: config.dig(:views, view_name), table: self) }
     end
 
     # Returns true if the table has filters
@@ -64,6 +87,15 @@ module Mensa
       columns.any?(&:filter?)
     end
 
+    # Returns the active filters, skipping any whose column no longer exists.
+    def active_filters
+      (config[:filters] || {}).filter_map do |column_name, filter_config|
+        col = column(column_name)
+        next unless col
+        Mensa::Filter.new(column: col, config: filter_config, table: self)
+      end
+    end
+
     def actions?
       config[:actions].present?
     end
@@ -74,10 +106,27 @@ module Mensa
       @actions ||= config[:actions].keys.map { |action_name| Mensa::Action.new(action_name, config: config.dig(:actions, action_name), table: self) }
     end
 
+    def batch_actions?
+      config[:batches].present?
+    end
+
+    def batch_actions
+      return @batch_actions if @batch_actions
+
+      @batch_actions ||= config[:batches].keys.map { |batch_name| Mensa::BatchAction.new(batch_name, config: config.dig(:batches, batch_name), table: self) }
+    end
+
     # Returns the current path with configuration
-    def path(order: {}, turbo_frame_id: nil, table_view_id: nil)
+    def path(order: {}, turbo_frame_id: nil, table_view_id: params[:table_view_id], column_order: params[:column_order], hidden_columns: params[:hidden_columns])
       # FIXME: if someone doesn't use as: :mensa in the routes, it breaks
-      original_view_context.mensa.table_path(name, order: order_hash(order), turbo_frame_id: turbo_frame_id, table_view_id: table_view_id)
+      original_view_context.mensa.table_path(
+        name,
+        order: order_hash(order),
+        turbo_frame_id: turbo_frame_id,
+        table_view_id: table_view_id,
+        column_order: column_order,
+        hidden_columns: hidden_columns
+      )
     end
 
     def menu
@@ -88,12 +137,16 @@ module Mensa
 
     def all_views
       views = system_views
-      views += TableView.where(table_name: name).where(user: [nil, Current.user])
+      views += TableView.where(table_name: name).where(user: [nil, current_user])
       views
     end
 
-    def active_filters
-      (config[:filters] || {}).map { |column_name, filter_config| Mensa::Filter.new(column: column(column_name), config: filter_config, table: self) }
+    # The user that owns custom views. Returns nil when the host application has
+    # no current user, in which case views cannot be saved.
+    def current_user
+      return Current.user if defined?(Current) && Current.respond_to?(:user)
+
+      nil
     end
 
     def table_id
@@ -108,9 +161,42 @@ module Mensa
 
     private
 
-    class << self
-      def definition(&)
-        @definition ||= Mensa::Config::TableDsl.new(name, &).config
+    def ensure_internal_columns_for_joined_associations
+      config[:columns] ||= {}
+
+      auto_internal_column_names.each do |column_name|
+        config[:columns][column_name] ||= {internal: true}
+      end
+    end
+
+    def auto_internal_column_names
+      joined_association_names.filter_map do |association_name|
+        reflection = model.reflect_on_association(association_name)
+        reflection&.foreign_key&.to_sym
+      end.uniq
+    end
+
+    def joined_association_names
+      relation = scope
+      return [] unless relation.respond_to?(:joins_values) && relation.respond_to?(:left_outer_joins_values)
+
+      (relation.joins_values + relation.left_outer_joins_values).flat_map do |join_value|
+        association_names_from_join_value(join_value)
+      end.compact.uniq
+    end
+
+    def association_names_from_join_value(join_value)
+      case join_value
+      when Symbol, String
+        [join_value.to_sym]
+      when Array
+        join_value.flat_map { |value| association_names_from_join_value(value) }
+      when Hash
+        join_value.flat_map do |association_name, nested_join_values|
+          [association_name.to_sym, *association_names_from_join_value(nested_join_values)]
+        end
+      else
+        []
       end
     end
   end

data/app/tables/mensa/batch_action.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Mensa
+  # Represents a batch action that can be applied to multiple selected records.
+  #
+  # batch :archive do
+  #   title "Archive"
+  #   process { |records| records.update_all(archived: true) }
+  # end
+  class BatchAction
+    include ConfigReaders
+
+    defined_by Mensa::Config::BatchDsl
+
+    attr_reader :name, :table
+
+    def initialize(name, config:, table:)
+      @name = name
+      @table = table
+      @config = config
+    end
+
+    config_reader :title
+    config_reader :description
+    config_reader :process, call: false
+  end
+end

data/app/tables/mensa/cell.rb

@@ -24,7 +24,7 @@ module Mensa
       if proc
         row.table.original_view_context.instance_exec(row.record, &proc)
       else
-        send("to_#{format}".to_sym)
+        send(:"to_#{format}")
       end
     end
 
@@ -33,18 +33,33 @@ module Mensa
     def to_html
       case value
       when NilClass
-        ''
+        ""
       when TrueClass
-        content_tag(:i, '', class: 'fa-solid fa-check')
+        content_tag(:i, "", class: "fa-solid fa-check")
       when FalseClass
-        content_tag(:i, '', class: 'fa-solid fa-xmark')
+        content_tag(:i, "", class: "fa-solid fa-xmark")
       when Date
-        respond_to?(:dt) ? dt(value) : value.strftime('%d.%m.%Y')
+        respond_to?(:dt) ? dt(value) : value.strftime("%d.%m.%Y")
       when Time, DateTime
-        respond_to?(:ln) ? ln(value) : value.strftime('%d-%m-%Y %H:%M:%S')
+        respond_to?(:ln) ? ln(value) : value.strftime("%d-%m-%Y %H:%M:%S")
       else
         column.sanitize? ? sanitize(value.to_s) : value.to_s.html_safe
       end
     end
+
+    def to_csv
+      case value
+      when NilClass
+        ""
+      when TrueClass, FalseClass
+        value.to_s
+      when Date
+        respond_to?(:dt) ? dt(value) : value.strftime("%d.%m.%Y")
+      when Time, DateTime
+        respond_to?(:ln) ? ln(value) : value.strftime("%d-%m-%Y %H:%M:%S")
+      else
+        strip_tags(value.to_s)
+      end
+    end
   end
 end

data/app/tables/mensa/column.rb

@@ -3,7 +3,10 @@
 module Mensa
   class Column
     include ConfigReaders
-    attr_reader :name, :table, :config
+
+    defined_by Mensa::Config::ColumnDsl
+
+    attr_reader :name, :table
 
     def initialize(name, config:, table:)
       @name = name
@@ -18,7 +21,8 @@ module Mensa
     config_reader :method # When a method needs to be called on the model, slow!
 
     def sort_direction
-      table.config.dig(:order, name)&.to_sym
+      value = table.config.dig(:order, name)
+      value.present? ? value.to_sym : nil
     end
 
     def next_sort_direction
@@ -35,24 +39,32 @@ module Mensa
       return @attribute if @attribute
 
       @attribute = if config[:attribute].present?
-                     "#{config[:attribute]} AS #{name}"
-                   elsif table.model.column_names.include? name.to_s
-                     name.to_s
-                   else
-                     nil
-                   end
+        "#{config[:attribute]} AS #{name}"
+      elsif table.model.column_names.include? name.to_s
+        name.to_s
+      end
+    end
+
+    def active_record_column
+      @active_record_column ||= table.model&.columns&.find { _1.name == name.to_s }
+    end
+
+    def active_record_column_type
+      active_record_column&.type
+    end
+
+    def type
+      config[:type] || active_record_column_type
     end
 
     def attribute_for_condition
       return @attribute_for_condition if @attribute_for_condition
 
       @attribute_for_condition = if config[:attribute].present?
-                                   config[:attribute]
-                                 elsif table.model.column_names.include? name.to_s
-                                   name.to_s
-                                 else
-                                   nil
-                                 end
+        config[:attribute]
+      elsif table.model.column_names.include? name.to_s
+        name.to_s
+      end
     end
 
     # Returns true if the column supports filtering
@@ -63,7 +75,7 @@ module Mensa
     def filter
       return unless filter?
 
-      @filter ||= Mensa::Filter.new(column: self, config: table.config.dig(:filters, name) || {}, table: table)
+      @filter ||= Mensa::Filter.new(column: self, config: table.config.dig(:columns, name, :filter) || {}, table: table)
     end
 
     def human_name
@@ -75,19 +87,12 @@ module Mensa
     end
 
     def menu
-      Satis::Menus::Builder.build(:filter_menu, event: 'click') do |m|
+      Satis::Menus::Builder.build(:filter_menu, event: "click") do |m|
         if sortable?
-          m.item :sort_ascending, icon: 'fa-solid fa-arrow-up-short-wide'.freeze, link: table.path(order: { name => :asc }), link_attributes: { "data-turbo-frame": "_self" }
-          m.item :sort_descending, icon: 'fa-solid fa-arrow-down-wide-short'.freeze, link: table.path(order: { name => :asc }), link_attributes: { "data-turbo-frame": "_self" }
+          m.item :sort_ascending, icon: "fa-solid fa-arrow-up-short-wide", link: table.path(order: {name => :asc}), link_attributes: {"data-turbo-frame": "_self"}
+          m.item :sort_descending, icon: "fa-solid fa-arrow-down-wide-short", link: table.path(order: {name => :desc}), link_attributes: {"data-turbo-frame": "_self"}
         end
       end
     end
-
-    private
-    class << self
-      def definition(&)
-        @definition ||= Mensa::Config::ColumnDsl.new(self.name, &).config
-      end
-    end
   end
 end

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

@@ -4,7 +4,7 @@ module Mensa::Config
   class ActionDsl
     include DslLogic
 
-    option :title, default: ->() { name }
+    option :title, default: -> { name }
     option :icon
     option :show, default: ->(record) { true }
     option :link

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mensa::Config
+  class BatchDsl
+    include DslLogic
+
+    option :title, default: -> { name.to_s.humanize }
+    option :description, default: ""
+    option :process, default: ->(records) {}
+
+    delegate :t, to: :I18n
+  end
+end

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

@@ -15,6 +15,7 @@ module Mensa::Config
     # Mensa doesn't select the whole records, to only select what we need
     option :internal, default: false
     option :method
+    option :type
 
     option :visible, default: true
     option :render, dsl: Mensa::Config::RenderDsl

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

@@ -65,11 +65,11 @@ module Mensa::Config
       end
 
       ###
-      # Define a DSL hash
-      # by calling option :action, dsl: Mensa::ActionDsl
+      # Define a DSL that builds a hash
+      # by calling option :action, dsl_hash: Mensa::ActionDsl
       #
       def dsl_hash(option_name, klass, config_name:)
-        config_name = config_name || option_name.to_s.pluralize.to_sym
+        config_name ||= option_name.to_s.pluralize.to_sym
 
         @default_config ||= {}
         @default_config[option_name.to_sym] = {}
@@ -80,8 +80,12 @@ module Mensa::Config
         end
       end
 
+      ###
+      # Define a DSL that builds an array
+      # by calling option :action, dsl_array: Mensa::ActionDsl
+      #
       def dsl_array(option_name, klass, config_name: option_name.to_s.pluralize.to_sym)
-        config_name = config_name || option_name.to_s.pluralize.to_sym
+        config_name ||= option_name.to_s.pluralize.to_sym
 
         @default_config ||= {}
         @default_config[name.to_sym] = []

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

@@ -2,9 +2,12 @@ module Mensa::Config
   class FilterDsl
     include DslLogic
 
-    option :operator, default: :equals
+    option :operator, default: :is
     option :value
     option :collection
     option :scope
+    option :multiple, default: false
+    option :as
+    option :operators
   end
 end

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

@@ -3,6 +3,6 @@ module Mensa::Config
     include DslLogic
 
     option :html
-    option :xlsx
+    option :csv
   end
 end

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

@@ -5,7 +5,7 @@
 #     render do # default Standard components
 #       html # Mensa::TableComponent::Default
 #       json # Mensa::JsonRenderer::Default
-#       xlsx # Mensa::XlsxRenderer::Default
+#       csv # Mensa::CsvRenderer::Default
 #     end
 #
 #     column(:first_name) do
@@ -55,6 +55,7 @@ module Mensa::Config
         raise "No model found for #{self.class.name}"
       end
     }
+    option :scope, default: -> { model.all }
     option :column, dsl_hash: Mensa::Config::ColumnDsl
     option :link
 
@@ -70,16 +71,25 @@ module Mensa::Config
     # Actions
     option :action, dsl_hash: Mensa::Config::ActionDsl
 
+    option :batch, dsl_hash: Mensa::Config::BatchDsl
+
     option :render, dsl: Mensa::Config::RenderDsl
 
     option :supports_views, default: false
     option :supports_custom_views, default: false
     option :supports_filters, default: true
     option :show_header, default: true
-    option :view_columns_sorting, default: true
-    option :view_condensed, default: false
-    option :view_condensed_toggle, default: true
+    # Whether the table allows to change column ordering
+    option :view_columns_ordering, default: true
 
     option :view, dsl_hash: Mensa::Config::ViewDsl
+
+    # Syntactic sugar for `column :carrier_id do internal true end`.
+    def internal(name, &block)
+      column(name) do
+        internal true
+        instance_exec(&block) if block
+      end
+    end
   end
 end

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

@@ -5,5 +5,7 @@ module Mensa::Config
     option :name
     option :description
     option :filter, dsl_hash: Mensa::Config::FilterDsl
+    option :column_order
+    option :hidden_columns
   end
 end

data/app/tables/mensa/config_readers.rb

@@ -2,12 +2,43 @@ module Mensa
   module ConfigReaders
     extend ActiveSupport::Concern
 
+    included do
+      attr_reader :config
+    end
+
     class_methods do
+      def defined_by(dsl_class)
+        # Lazily-built DSL instance that accumulates configuration.
+        define_singleton_method(:dsl_definition) do
+          @dsl_definition ||= dsl_class.new(name)
+        end
+
+        define_singleton_method(:definition) do |&block|
+          dsl_definition.instance_eval(&block) if block
+          dsl_definition.config
+        end
+
+        # Forward unknown class-level calls to the DSL
+        define_singleton_method(:method_missing) do |method_name, *args, &block|
+          if dsl_definition.respond_to?(method_name)
+            dsl_definition.public_send(method_name, *args, &block)
+          else
+            super(method_name, *args, &block)
+          end
+        end
+
+        define_singleton_method(:respond_to_missing?) do |method_name, include_private = false|
+          dsl_definition.respond_to?(method_name, include_private) || super(method_name, include_private)
+        end
+      end
+
       # Set call to false to avoid immediate execution of Procs
-      def config_reader(name, call: true)
+      def config_reader(name, call: true, cast: nil)
         define_method name do
-          value = config[name.to_s.gsub("?", "").to_sym]
-          call == true && value.is_a?(Proc) ? instance_exec(&value) : value
+          value = config[name.to_s.delete("?").to_sym]
+          value = (call == true && value.is_a?(Proc)) ? instance_exec(&value) : value
+          value = value.send(cast) if cast
+          value
         end
       end
     end