mensa 0.2.5 → 0.2.6

data/app/controllers/mensa/tables/batch_actions_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Mensa
+  module Tables
+    class BatchActionsController < ::ApplicationController
+      def create
+        table_name = params[:table_id]
+        batch_action_name = params[:batch_action_name]&.to_sym
+        record_ids = Array(params[:record_ids])
+
+        table = Mensa.for_name(table_name)
+        table.original_view_context = helpers
+
+        batch_action = table.batch_actions.find { |a| a.name == batch_action_name }
+        return head :not_found unless batch_action
+
+        records = table.model.where(id: record_ids).to_a
+        batch_action.process.call(records)
+
+        redirect_back_or_to helpers.mensa.table_path(table_name)
+      end
+    end
+  end
+end

data/app/controllers/mensa/tables/exports_controller.rb

@@ -0,0 +1,96 @@
+module Mensa
+  module Tables
+    # Lists a user's available downloads for a table and creates new export
+    # requests. Generating the CSV happens asynchronously in Mensa::ExportJob;
+    # both the export button badge and the downloads list are refreshed via
+    # Turbo streams once the job completes.
+    class ExportsController < ::ApplicationController
+      # Returns the current downloads list for the table, used to refresh the
+      # contents of the export dialog when it is opened.
+      def index
+        respond_to do |format|
+          format.turbo_stream { render turbo_stream: list_stream }
+          format.html { render partial: "mensa/exports/list", locals: list_locals }
+        end
+      end
+
+      # Creates a new export for the current user and enqueues the job that
+      # generates and attaches the CSV.
+      def create
+        export = Mensa::Export.new(
+          table_name: params[:table_id],
+          table_view_id: params[:table_view_id].presence,
+          user: current_mensa_user,
+          format: params[:export_format].to_s.presence_in(Mensa::Export::FORMATS) || "csv_excel",
+          scope: params[:scope].to_s.presence_in(Mensa::Export::SCOPES) || "all",
+          config: params.permit(:query, :page, order: {}, filters: {}).to_h,
+          status: "pending"
+        )
+
+        if export.save
+          Mensa::ExportJob.perform_later(export)
+
+          respond_to do |format|
+            format.turbo_stream { render turbo_stream: [list_stream, badge_stream] }
+            format.json { render json: {id: export.id}, status: :created }
+          end
+        else
+          respond_to do |format|
+            format.turbo_stream { head :unprocessable_entity }
+            format.json { render json: {errors: export.errors.full_messages}, status: :unprocessable_entity }
+          end
+        end
+      end
+
+      # Streams the generated CSV and then removes the export, purging the
+      # attached asset. Downloads are single-use: routing them through the
+      # controller (instead of a direct Active Storage link) gives us a hook to
+      # delete the Mensa::Export record and free the stored file afterwards.
+      def download
+        export = exports.find(params[:id])
+        return head :not_found unless export.downloadable?
+
+        data = export.asset.download
+        filename = export.asset.filename.to_s.presence || export.filename.presence || "#{export.table_name}_export.csv"
+        content_type = export.asset.content_type.presence || "text/csv"
+
+        send_data data, filename: filename, type: content_type, disposition: "attachment"
+
+        # Clean up after a successful send. `has_one_attached :asset` purges the
+        # blob when the record is destroyed (dependent: :purge_later). Never let
+        # cleanup failures break the download itself.
+        begin
+          export.destroy
+          Mensa::Export.broadcast_refresh(export.table_name, export.user)
+        rescue => e
+          Mensa.config.logger&.warn("Mensa::Export cleanup failed for #{export.id}: #{e.class}: #{e.message}")
+        end
+      end
+
+      private
+
+      def exports
+        @exports ||= Mensa::Export.for_table(params[:table_id]).for_user(current_mensa_user).recent
+      end
+
+      def list_stream
+        turbo_stream.replace(Mensa::Export.list_dom_id(params[:table_id], current_mensa_user),
+          partial: "mensa/exports/list", locals: list_locals)
+      end
+
+      def badge_stream
+        turbo_stream.replace(Mensa::Export.badge_dom_id(params[:table_id], current_mensa_user),
+          partial: "mensa/exports/badge",
+          locals: {table_name: params[:table_id], user: current_mensa_user})
+      end
+
+      def list_locals
+        {table_name: params[:table_id], user: current_mensa_user, exports: exports}
+      end
+
+      def current_mensa_user
+        Current.user if defined?(Current) && Current.respond_to?(:user)
+      end
+    end
+  end
+end

data/app/controllers/mensa/tables/filters_controller.rb

@@ -16,10 +16,13 @@ module Mensa
 
       # Returns the filter information on the column-name
       def show
-        config = {}.merge(params.permit(:id, :page, :table_id, :target, :table_view_id, :turbo_frame_id, order: {}, filters: {}).to_h)
+        config = {}.merge(params.permit(:id, :value, :operator, :page, :table_id, :target, :table_view_id, :turbo_frame_id, order: {}, filters: {}).to_h)
         @table = Mensa.for_name(params[:table_id], config)
         @table.original_view_context = helpers
         @column = @table.column(params[:id])
+        @operator = params[:operator].presence || "is"
+        @multiple = @column.filter.multiple?
+        @values = Array(params[:value]).flatten.compact
         respond_to do |format|
           format.turbo_stream
           format.html

data/app/controllers/mensa/tables/views_controller.rb

@@ -0,0 +1,108 @@
+module Mensa
+  module Tables
+    class ViewsController < ::ApplicationController
+      # Persists the current filters, ordering and search query as a named
+      # custom view, owned by the current user. Without a current user there is
+      # nobody to own the view, so the request is rejected (and the UI hides the
+      # save button in that case).
+      def create
+        user = current_mensa_user
+        return head(:forbidden) if user.blank?
+
+        view = Mensa::TableView.new(
+          table_name: params[:table_id],
+          name: params[:name],
+          description: params[:description],
+          config: view_config,
+          user: user
+        )
+
+        if view.save
+          respond_to do |format|
+            format.turbo_stream do
+              # Re-use the same turbo_frame_id that the client sent so the
+              # generated element IDs match what is already in the DOM.
+              table_config = view.config
+                .deep_transform_keys(&:to_sym)
+                .merge(turbo_frame_id: params[:turbo_frame_id])
+
+              @table = Mensa.for_name(params[:table_id], table_config)
+              @table.request = request
+              @table.original_view_context = helpers
+              @table.table_view = view
+            end
+            format.json { render json: {id: view.id, name: view.name}, status: :created }
+          end
+        else
+          render json: {errors: view.errors.full_messages}, status: :unprocessable_entity
+        end
+      end
+
+      def update
+        user = current_mensa_user
+        return head(:forbidden) if user.blank?
+
+        view = Mensa::TableView.find_by(table_name: params[:table_id], id: params[:id], user: user)
+        return head(:not_found) if view.blank?
+
+        # When only renaming, preserve the existing config rather than overwriting
+        # with an empty hash from view_config.
+        new_config = view_config
+        update_attrs = {config: new_config.present? ? new_config : view.config}
+        update_attrs[:name] = params[:name] if params[:name].present?
+
+        if view.update(update_attrs)
+          respond_to do |format|
+            format.turbo_stream do
+              table_config = view.config
+                .deep_transform_keys(&:to_sym)
+                .merge(turbo_frame_id: params[:turbo_frame_id])
+
+              @table = Mensa.for_name(params[:table_id], table_config)
+              @table.request = request
+              @table.original_view_context = helpers
+              @table.table_view = view
+            end
+            format.json { render json: {id: view.id, name: view.name} }
+          end
+        else
+          render json: {errors: view.errors.full_messages}, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        user = current_mensa_user
+        return head(:forbidden) if user.blank?
+
+        view = Mensa::TableView.find_by(table_name: params[:table_id], id: params[:id], user: user)
+        return head(:not_found) if view.blank?
+
+        view.destroy
+
+        respond_to do |format|
+          format.turbo_stream do
+            @table = Mensa.for_name(params[:table_id], {turbo_frame_id: params[:turbo_frame_id]})
+            @table.request = request
+            @table.original_view_context = helpers
+          end
+          format.json { head :no_content }
+        end
+      end
+
+      private
+
+      # The view configuration mirrors the query parameters the table reads on
+      # show (query, ordering and filters), so a saved view can be replayed by
+      # merging this hash back into the request params.
+      def view_config
+        config = params.permit(:query, order: {}, column_order: [], hidden_columns: []).to_h
+        config[:filters] = params[:filters]&.to_unsafe_h || {}
+        config
+      end
+
+      def current_mensa_user
+        Current.user if defined?(Current) && Current.respond_to?(:user)
+      end
+    end
+  end
+end

data/app/controllers/mensa/tables_controller.rb

@@ -7,11 +7,12 @@ module Mensa
       if params[:table_view_id]
         @view = Mensa::TableView.find_by(table_name: params[:id], id: params[:table_view_id])
         @view ||= @table.system_views.find { |v| v.id == params[:table_view_id].to_sym }
-        config = @view&.config
+        config = @view&.config&.deep_transform_keys(&:to_sym)
       end
 
       config = config.merge(params.permit!.to_h)
-      config = config.merge(params.permit(:format, :query, :id, :page, :table_view_id, :turbo_frame_id, order: {}, filters: {}).to_h)
+      config = config.merge(params.permit(:format, :query, :id, :page, :table_view_id, :turbo_frame_id, order: {}, column_order: [], hidden_columns: []).to_h)
+      config[:filters] = params[:filters]&.to_unsafe_h || config[:filters] || {}
 
       @table = Mensa.for_name(params[:id], config)
       @table.request = request
@@ -21,10 +22,6 @@ module Mensa
       respond_to do |format|
         format.turbo_stream # Used for filterering
         format.html
-        format.xlsx do
-          Mensa::ExportJob.perform_later(current_user, params[:id])
-          head :ok
-        end
       end
     end
   end

data/app/helpers/mensa/application_helper.rb

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

data/app/javascript/mensa/application.js

@@ -1,2 +1,2 @@
-import "@hotwired/turbo-rails"
-import "mensa/controllers"
+import "@hotwired/turbo-rails";
+import "mensa/controllers";

data/app/javascript/mensa/controllers/index.js

@@ -1,4 +1,4 @@
-import { application } from "mensa/controllers/application"
+import { application } from "mensa/controllers/application";
 
 // import AddFilterComponentController from 'components/add_filter/component_controller';
 // application.register('mensa-add-filter', AddFilterComponentController)
@@ -10,17 +10,26 @@ import FilterPillComponentController from "mensa/components/filter_pill/componen
 application.register("mensa-filter-pill", FilterPillComponentController);
 
 import FilterPillListComponentController from "mensa/components/filter_pill_list/component_controller";
-application.register("mensa-filter-pill-list", FilterPillListComponentController);
+application.register(
+    "mensa-filter-pill-list",
+    FilterPillListComponentController,
+);
 
 import SearchComponentController from "mensa/components/search/component_controller";
 application.register("mensa-search", SearchComponentController);
 
-import TableComponentController from 'mensa/components/table/component_controller'
+import TableComponentController from "mensa/components/table/component_controller";
 application.register("mensa-table", TableComponentController);
 
-import ViewsComponentController from 'mensa/components/views/component_controller'
+import ViewsComponentController from "mensa/components/views/component_controller";
 application.register("mensa-views", ViewsComponentController);
 
+import SelectionComponentController from "mensa/components/selection/component_controller";
+application.register("mensa-selection", SelectionComponentController);
+
+import ColumnCustomizerController from "mensa/components/column_customizer/component_controller";
+application.register("mensa-column-customizer", ColumnCustomizerController);
+
 // Eager load all controllers defined in the import map under controllers/**/*_controller
 // import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading"
 // eagerLoadControllersFrom("controllers", application)

data/app/jobs/mensa/export_job.rb

@@ -1,110 +1,103 @@
+require "csv"
 require "securerandom"
+require "stringio"
 
 module Mensa
+  # Generates the CSV for a Mensa::Export, attaches it to the export's +asset+
+  # and broadcasts the refreshed export button badge and downloads list so the
+  # requesting user sees the finished download appear without reloading.
   class ExportJob < ApplicationJob
     queue_as :default
 
-    # export_started: lambda do |user_id, table_name|
-    # end,
-    # export_complete: lambda do |user_id, table_name, attachment|
-    # end
+    def perform(export)
+      return unless export
 
-    def perform(user, table_name)
-      table = Mensa.for_name(table_name)
-      return unless table.exportable?
+      export.update(status: "processing")
+      Mensa.config.callbacks[:export_started]&.call(export)
 
-      context = Mensa.config.callbacks[:export_started].call(user, table_name)
-
-      styles = []
-      default_style = {b: true, bg_color: "3B82F6", fg_color: "FFFFFF", border: {style: :thin, color: "000000"}, sz: 8,
-                       alignment: {vertical: :bottom, horizontal: :left}}
+      table = build_table(export)
+      unless table.exportable?
+        finalize(export, status: "failed")
+        return
+      end
 
-      p = Axlsx::Package.new
-      p.use_shared_strings = true
+      data, filename, content_type = generate(table, export)
 
-      wb = p.workbook
+      export.asset.attach(io: StringIO.new(data), filename: filename, content_type: content_type)
+      finalize(export, status: "completed", filename: filename)
 
-      wb.styles.add_style({format_code: "@", alignment: {horizontal: :left, vertical: :top, wrap_text: true}})
-      nowrap_text = wb.styles.add_style({format_code: "@", alignment: {horizontal: :left, vertical: :top, wrap_text: false}})
-      wb.styles.add_style format_code: "#"
-      wb.styles.add_style format_code: "dddd, d mmmm yyyy hh:mm:ss"
-      wb.styles.add_style format_code: "dddd, d mmmm yyyy"
+      Mensa.config.callbacks[:export_complete]&.call(export)
+    rescue => e
+      Mensa.config.logger&.error("Mensa::ExportJob failed for export #{export_id}: #{e.class}: #{e.message}")
+      finalize(export, status: "failed") if export
+      raise
+    end
 
-      # custom_styles = ActionTable.config.format_config.each_with_object({}) { |(key, value), hash| hash[key] = value[:xlsx_style] if value.key?(:xlsx_style) }
+    private
 
-      wb.add_worksheet(name: table_name.first(31)) do |sheet|
-        column_widths = []
-        # TODO: Separate display columns for export?
-        table.display_columns.map.with_index do |column, index|
-          styles[index] = sheet.styles.add_style(default_style) # .merge(column.export_style || {}))
-          # width = column.export_style.delete(:width)
-          # column_widths[index] = width if width
-        end
+    # Rebuilds the table the export was requested for, layering the view
+    # configuration (if any) underneath the captured request configuration
+    # (filters, query, ordering, page) so the generated data matches what the
+    # user saw when they requested the export.
+    def build_table(export)
+      config = {}
 
-        first_row = sheet.add_row(table.display_columns.map { |c| c.human_name }, style: styles, height: 28)
-
-        first_cell = first_row.first
-        last_row = first_row
-
-        table.export_rows.each do |row|
-          # next if row.reject { |column, value| value.nil? || value == '' }.blank?
-          #
-          # row_types = :string #row.map(&:second)
-          # row_values = row.map(&:third)
-          # options = row.map(&:last)
-          #
-          # row_styles = options.map.with_index { |option, i|
-          #   type = row_types[i]
-          #   value = row_values[i]
-          #   export_style = option.dig(:export, :xlsx_style)
-          #
-          #   if export_style.present?
-          #     wb.styles.add_style(export_style)
-          #   elsif custom_styles[type].present?
-          #     wb.styles.add_style(custom_styles[type])
-          #   elsif [:integer, :float, :decimal, :number].include?(type)
-          #     number_format
-          #   elsif [:datetime, :time, :timestamp].include?(type)
-          #     datetime_format
-          #   elsif type == :date
-          #     date_format
-          #   elsif value.is_a?(Axlsx::RichText) || type == :text
-          #     wrap_text
-          #   else
-          #     nowrap_text
-          #   end
-          # }
-          values = table.display_columns.map { |column| row.value(column) }
-          row_styles = table.display_columns.map { |column| nowrap_text }
-          last_row = sheet.add_row(values, style: row_styles)
-        end
+      if export.table_view_id.present?
+        view = Mensa::TableView.find_by(table_name: export.table_name, id: export.table_view_id)
+        config = view.config.deep_symbolize_keys if view&.config
+      end
 
-        last_cell = last_row.last
+      config = config.merge((export.config.compact_blank || {}).deep_symbolize_keys)
+      table = Mensa.for_name(export.table_name, config)
+      table.request = ActionDispatch::Request.new({})
+      table.request.set_header("action_dispatch.request.query_parameters", {"page" => config[:page]})
+      table
+    end
 
-        sheet.column_widths(*column_widths)
-        sheet.auto_filter = Axlsx.cell_range([first_cell, last_cell], false)
+    def generate(table, export)
+      io = StringIO.new
+      # A UTF-8 BOM makes spreadsheet programs such as Excel detect the encoding
+      # correctly. The "plain" CSV variant omits it for maximum compatibility
+      # with programmatic consumers.
+      io.write("\uFEFF") if export.format == "csv_excel"
+
+      csv = CSV.new(io)
+      csv << table.display_columns.map(&:name)
+      export_rows(table, export).each do |row|
+        csv << table.display_columns.map { |column| Mensa::Cell.new(row: row, column: column).render(:csv) }
       end
+      io.rewind
+      data = io.read
+
+      base_filename = "#{export.table_name}_export_#{export.created_at.strftime("%Y-%m-%d-%H%M%S")}"
 
-      base_filename = "#{table_name}_export_#{Time.current.strftime("%Y-%m-%d-%H:%M:%S")}"
-      enc = nil
-      password = nil
       if table.export_with_password?
+        require "zip"
         password = SecureRandom.hex(6)
-        enc = Zip::TraditionalEncrypter.new(password)
-      end
-      stringio = Zip::OutputStream.write_buffer(encrypter: enc) do |zio|
-        zio.put_next_entry("#{base_filename}.xlsx")
-        zio.write p.to_stream.read
+        encrypter = Zip::TraditionalEncrypter.new(password)
+        zip_io = Zip::OutputStream.write_buffer(encrypter: encrypter) do |zio|
+          zio.put_next_entry("#{base_filename}.csv")
+          zio.write data
+        end
+        zip_io.rewind
+        [zip_io.read, "#{base_filename}.zip", "application/zip"]
+      else
+        [data, "#{base_filename}.csv", "text/csv"]
       end
-      stringio.rewind
+    end
 
-      attachment = {io: stringio,
-                    content_type: "application/zip", filename: "#{base_filename}.zip"}
-      if password.present?
-        attachment[:password] = password
-      end
+    def export_rows(table, export)
+      scope = (export.scope == "current_page") ? table.paged_scope : table.selected_scope
+      scope.map { |row| Mensa::Row.new(table, row) }
+    end
 
-      Mensa.config.callbacks[:export_completed].call(user, table_name, context, attachment)
+    def finalize(export, status:, filename: nil)
+      attributes = {status: status}
+      attributes[:filename] = filename if filename
+      export.update(attributes)
+      # Refresh the export button badge (download count) and the downloads list
+      # inside the export dialog for everyone viewing this table.
+      Mensa::Export.broadcast_refresh(export.table_name, export.user)
     end
   end
 end

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