mensa 0.1.0 → 0.1.3

data/app/controllers/mensa/application_controller.rb

@@ -0,0 +1,4 @@
+module Mensa
+  class ApplicationController < ActionController::Base#::Mensa.config.base_controller.constantize
+  end
+end

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

@@ -0,0 +1,29 @@
+module Mensa
+  module Tables
+    class FiltersController < ::ApplicationController
+      layout false
+
+      class Filter
+        include ActiveModel::Model
+        attr_accessor :value
+      end
+
+      def index
+        config = {}.merge(params.permit(:id, :page, :table_id, :target, :table_view_id, :turbo_frame_id, order: {}, filters: {}).to_h)
+        @table = Mensa.for_name(params[:table_id], config)
+      end
+
+      # 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)
+        @table = Mensa.for_name(params[:table_id], config)
+        @table.original_view_context = helpers
+        @column = @table.column(params[:id])
+        respond_to do |format|
+          format.turbo_stream
+          format.html
+        end
+      end
+    end
+  end
+end

data/app/controllers/mensa/tables_controller.rb

@@ -0,0 +1,37 @@
+module Mensa
+  class TablesController < ::ApplicationController
+    layout :decide_layout
+
+    def index
+      render layout: 'mensa/application'
+    end
+
+    def show
+      config = if params[:table_view_id]
+                 @view = Mensa::TableView.find_by(table_name: params[:id], id: params[:table_view_id])
+                 @view&.data || {}
+               else
+                 {}
+               end
+
+      config = config.merge(params.permit(:format, :query, :id, :page, :table_view_id, :turbo_frame_id, order: {}, filters: {}).to_h)
+
+      @table = Mensa.for_name(params[:id], config)
+      @table.table_view = @view
+      @table.original_view_context = helpers
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html
+        format.xlsx do
+          Mensa::ExportJob.perform_async(current_user.id, params[:id])
+          head 200
+        end
+      end
+    end
+
+    def decide_layout
+      return false if params[:turbo_frame_id]
+    end
+  end
+end

data/app/helpers/mensa/application_helper.rb

@@ -0,0 +1,5 @@
+module Mensa
+  module ApplicationHelper
+
+  end
+end

data/app/helpers/mensa/tables_helper.rb

@@ -0,0 +1,5 @@
+module Mensa
+  module TablesHelper
+    include Pagy::Frontend
+  end
+end

data/app/javascript/mensa/application.js

@@ -0,0 +1,3 @@
+import "@fortawesome/fontawesome-free"
+import "@hotwired/turbo-rails"
+import "mensa/controllers"

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

@@ -0,0 +1,7 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  alert() {
+    alert("alert")
+  }
+}

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

@@ -0,0 +1,8 @@
+import { Application } from "@hotwired/stimulus"
+
+const application = Application.start()
+
+application.debug = false
+window.Stimulus = application
+
+export { application }

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

@@ -0,0 +1,57 @@
+// application_controller.js
+import { Controller } from '@hotwired/stimulus'
+
+export default class ApplicationController extends Controller {
+  connect () {
+    this.element[this.identifier] = this
+  }
+
+  getController (element, identifier) {
+    return this.application.getControllerForElementAndIdentifier(element, identifier)
+  }
+
+  triggerEvent (el, name, data) {
+    let event
+    if (typeof window.CustomEvent === 'function') {
+      event = new CustomEvent(name, { detail: data, cancelable: true, bubbles: true })
+    } else {
+      event = document.createEvent('CustomEvent')
+      event.initCustomEvent(name, true, true, data)
+    }
+    el.dispatchEvent(event)
+  }
+
+  elementScrolled (element) {
+    if (element.scrollHeight - Math.round(element.scrollTop) === element.clientHeight) {
+      return true
+    }
+    return false
+  }
+
+  debouncedHover (element, timeout, handler) {
+    var timeoutId = null
+    element.addEventListener(marker, 'mouseover', function () {
+      timeoutId = setTimeout(handler, timeout)
+    })
+
+    element.addEventListener(marker, 'mouseout', function () {
+      clearTimeout(timeoutId)
+    })
+  }
+
+  get ourUrl () {
+    // This requires the mensaTableOutlet
+    let turboFrame = this.mensaTableOutlet?.turboFrameTarget
+    if(!turboFrame) {
+      turboFrame = this.turboFrameTarget
+    }
+    let url
+
+    if (turboFrame && turboFrame.getAttribute('src')) {
+      url = new URL(turboFrame.getAttribute('src'))
+    } else {
+      url = new URL(window.location.href)
+    }
+    return url
+  }
+}

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

@@ -0,0 +1,24 @@
+import { application } from "mensa/controllers/application"
+
+// import AddFilterComponentController from 'components/add_filter/component_controller';
+// application.register('mensa-add-filter', AddFilterComponentController)
+
+import AddFilterComponentController from "mensa/components/add_filter/component_controller";
+application.register("mensa-add-filter", AddFilterComponentController);
+
+import FiltersComponentController from "mensa/components/filters/component_controller";
+application.register("mensa-filters", FiltersComponentController);
+
+import SearchComponentController from "mensa/components/search/component_controller";
+application.register("mensa-search", SearchComponentController);
+
+import TableComponentController from 'mensa/components/table/component_controller'
+application.register("mensa-table", TableComponentController);
+
+// Eager load all controllers defined in the import map under controllers/**/*_controller
+// import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading"
+// eagerLoadControllersFrom("controllers", application)
+
+// Lazy load controllers as they appear in the DOM (remember not to preload controllers in import map!)
+// import { lazyLoadControllersFrom } from "@hotwired/stimulus-loading"
+// lazyLoadControllersFrom("controllers", application)

data/app/jobs/mensa/application_job.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mensa
+  class ApplicationJob
+    include Sidekiq::Job
+  end
+end

data/app/jobs/mensa/export_job.rb

@@ -0,0 +1,91 @@
+module Mensa
+  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(user_id, table_name)
+      table = Mensa.for_name(table_name)
+      context = Mensa.config.callbacks[:export_started].call(user_id, 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 } }
+
+      p = Axlsx::Package.new
+      p.use_shared_strings = true
+
+      wb = p.workbook
+
+      wrap_text = 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 } })
+      number_format = wb.styles.add_style format_code: '#'
+      datetime_format = wb.styles.add_style format_code: "dddd, d mmmm yyyy hh:mm:ss"
+      date_format = wb.styles.add_style format_code: "dddd, d mmmm yyyy"
+
+      # custom_styles = ActionTable.config.format_config.each_with_object({}) { |(key, value), hash| hash[key] = value[:xlsx_style] if value.key?(:xlsx_style) }
+      custom_style = {}
+
+      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
+
+        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
+
+        last_cell = last_row.last
+
+        sheet.column_widths(*column_widths)
+        sheet.auto_filter = Axlsx.cell_range([first_cell, last_cell], false)
+      end
+
+      attachment = { io: p.to_stream,
+                     content_type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', filename: "#{table_name}_export_#{Time.current.strftime("%Y-%m-%d-%H:%M:%S")}.xlsx" }
+
+      Mensa.config.callbacks[:export_completed].call(user_id, table_name, context, attachment)
+    end
+  end
+end

data/app/models/mensa/application_record.rb

@@ -0,0 +1,5 @@
+module Mensa
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/mensa/table_view.rb

@@ -0,0 +1,5 @@
+module Mensa
+  class TableView < ApplicationRecord
+    belongs_to :user, optional: true
+  end
+end

data/app/tables/mensa/action.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mensa
+  # Provide additional links at the end of the row, with an icon, link and a name
+  #
+  # action :delete do
+  #   link { |contact| delete_contact_path(contact) }
+  #   link_attributes "data-turbo-method" => "delete"
+  #   icon "fa-xmark"
+  # end
+  class Action
+    include ConfigReaders
+    attr_reader :name, :table, :config
+
+    def initialize(name, config:, table:)
+      @name = name
+      @table = table
+      @config = config
+    end
+
+    config_reader :link
+    config_reader :link_attributes
+    config_reader :icon
+    config_reader :show
+  end
+end

data/app/tables/mensa/base.rb

@@ -0,0 +1,103 @@
+module Mensa
+  class Base
+    include Pagy::Backend
+    include ConfigReaders
+    include Scope
+
+    attr_writer :original_view_context
+    attr_accessor :component, :name, :table_view
+    attr_reader :config, :params
+
+    config_reader :model
+    config_reader :link
+    config_reader :supports_views?
+    config_reader :view_condensed?
+    config_reader :view_condensed_toggle?
+    config_reader :view_columns_sorting?
+    config_reader :show_header?
+
+    def initialize(config = {})
+      @params = config.deep_symbolize_keys
+      @config = self.class.definition.merge(@params || {})
+    end
+
+    def column_order
+      config[:column_order] || config[:columns]&.keys
+    end
+
+    # Returns all columns
+    def columns
+      return @columns if @columns
+
+      @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)
+      columns.find { |c| c.name == name.to_sym }
+    end
+
+    # Returns the columns to be displayed
+    def display_columns
+      @display_columns ||= columns.select(&:visible?).reject(&:internal?)
+    end
+
+    # Returns the rows to be displayed
+    def rows
+      paged_scope.map { |row| Mensa::Row.new(self, row) }
+    end
+
+    def export_rows
+      ordered_scope.map { |row| Mensa::Row.new(self, row) }
+    end
+
+    def actions?
+      config[:actions].present?
+    end
+
+    def actions
+      return @actions if @actions
+
+      @actions ||= config[:actions].keys.map { |action_name| Mensa::Action.new(action_name, config: config.dig(:actions, action_name), table: self) }
+    end
+
+    # Returns the current path with configuration
+    def path(order: {}, turbo_frame_id: nil, table_view_id: nil)
+      # 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)
+    end
+
+    def menu
+      Satis::Menus::Builder.build([:table, :view_menu]) do |m|
+        m.item :export, icon: "fal fa-file-export", link: nil
+      end
+    end
+
+    def all_views
+      [Mensa::TableView.new(name: I18n.t('.mensa.views.all'))] + TableView.where(table_name: name).where(user: [nil, Current.user])
+    end
+
+    def active_filters
+      (config[:filters] || {}).map { |column_name, value| Mensa::Filter.new(value, column: column(column_name), config: config.dig(:filters, column_name), table: self) }
+    end
+
+    def table_id
+      return @table_id if @table_id
+
+      @table_id = params[:turbo_frame_id] || "#{name.to_s.gsub("/", "__")}-#{SecureRandom.base36}"
+    end
+
+    def original_view_context
+      @original_view_context || component.original_view_context
+    end
+
+    private
+
+    class << self
+      def definition(&)
+        @definition ||= Mensa::Config::TableDsl.new(self.name, &).config
+      end
+    end
+  end
+end

data/app/tables/mensa/cell.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Mensa
+  class Cell
+    include ActionView::Helpers::SanitizeHelper
+    include ::ApplicationHelper
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::UrlHelper
+    include Rails.application.routes.url_helpers
+
+    attr_reader :column, :row
+
+    def initialize(row:, column:)
+      @row = row
+      @column = column
+    end
+
+    def value
+      @value ||= row.value(column)
+    end
+
+    def render(format)
+      proc = column.config.dig(:render, format.to_sym)
+      if proc
+        row.table.original_view_context.instance_exec(row.record, &proc)
+      else
+        send("to_#{format}".to_sym)
+      end
+    end
+
+    private
+
+    def to_html
+      case value
+      when NilClass
+        ''
+      when TrueClass
+        content_tag(:i, '', class: 'fa fa-check')
+      when FalseClass
+        content_tag(:i, '', class: 'fa fa-xmark')
+      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
+        column.sanitize? ? sanitize(value.to_s) : value.to_s.html_safe
+      end
+    end
+  end
+end

data/app/tables/mensa/column.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Mensa
+  class Column
+    include ConfigReaders
+    attr_reader :name, :table, :config
+
+    def initialize(name, config:, table:)
+      @name = name
+      @table = table
+      @config = config
+    end
+
+    config_reader :sortable?
+    config_reader :sanitize?
+    config_reader :visible?
+    config_reader :internal?
+    config_reader :method # When a method needs to be called on the model, slow!
+
+    def sort_direction
+      table.config.dig(:order, name)&.to_sym
+    end
+
+    def next_sort_direction
+      if sort_direction == :asc
+        :desc
+      elsif sort_direction == :desc
+        nil
+      else
+        :asc
+      end
+    end
+
+    def attribute
+      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
+    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
+    end
+
+    def filter?
+      config.key?(:filter)
+    end
+
+    def filter
+      return unless filter?
+
+      @filter ||= Mensa::Filter.new(nil, column: self, config: config[:filter] || {}, table: table)
+    end
+
+    def human_name
+      if table.model < ActiveRecord::Base
+        table.model.human_attribute_name name
+      else
+        name.to_s.humanize
+      end
+    end
+
+    def menu
+      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" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Mensa::Config
+  class ActionDsl
+    include DslLogic
+
+    option :icon
+    option :show, default: ->(record) { true }
+    option :link
+    option :link_attributes, default: {}
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Mensa::Config
+  class ColumnDsl
+    include DslLogic
+
+    option :sortable, default: true
+    option :sanitize, default: true
+    # Allows for sql-parts too
+    #
+    #   attribute 'EXTRACT(YEAR FROM AGE(born_on))::int as age'
+    #
+    option :attribute
+    # Internal columns will never be shown, but are there to be selected, to be used in methods
+    # Mensa doesn't select the whole records, to only select what we need
+    option :internal
+    option :method
+
+    option :visible, default: :true
+    dsl_option :render, Mensa::Config::RenderDsl
+    dsl_option :filter, Mensa::Config::FilterDsl
+  end
+end