habarico 7.2.0.pre.beta.5

data/lib/habarico/generators/view/field_descriptor_generator.rb

@@ -0,0 +1,107 @@
+module Habarico
+  class FieldDescriptorGenerator < AbstractGenerator
+
+    def generate(model, field_reference, context, force_params = {})
+      # Fallback to a simple FieldReference object if a string or a symbol is provided
+      field_reference = Habarico::FieldReference.new(name: field_reference.to_s) if field_reference.is_a?(String) || field_reference.is_a?(Symbol)
+
+      # Validate argument
+      raise Eluvia::Errors::StandardError.new('Argument `field_reference` must be a Habarico::FieldReference') unless field_reference.is_a?(Habarico::FieldReference)
+
+      # Force parameters
+      field_reference.assign(force_params)
+
+      # Create model
+      Habarico::FieldDescriptor.new(
+        type: 'field',
+        name: generate_name(model, field_reference, context),
+        label: generate_label(model, field_reference, context),
+        short_label: generate_short_label(model, field_reference, context),
+        help_text: generate_help_text(model, field_reference, context),
+        sortable: generate_sortable(model, field_reference, context),
+        sort_by: generate_sort_by(model, field_reference, context),
+        read_only: generate_read_only(model, field_reference, context),
+        write_only: generate_write_only(model, field_reference, context),
+        default_value: generate_default_value(model, field_reference, context),
+        action: generate_action(model, field_reference, context),
+        wrapper: generate_wrapper(model, field_reference, context),
+        options: generate_options(model, field_reference, context)
+      )
+    end
+
+    protected
+
+    def field_options_generator
+      @field_options_generator ||= definition.field_options_generator.new(definition, resource_path)
+    end
+
+    def action_descriptor_generator
+      @action_descriptor_generator ||= definition.action_descriptor_generator.new(definition, resource_path)
+    end
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_name(_model, field_reference, _context)
+      field_reference.name
+    end
+
+    def generate_label(model, field_reference, _context)
+      return field_reference.label if field_reference.label.present?
+      Habarico::AttributesHelper.generate_attr_variants(model, field_reference.name).each do |attr_name_variant|
+        label = I18n.t("#{model.i18n_scope}.attributes.#{model.model_name.i18n_key}.#{attr_name_variant}", default: nil)
+        return label if label.present?
+      end
+      nil # In this case do not define label and use the default one from field schema
+    end
+
+    def generate_short_label(_model, field_reference, _context)
+      field_reference.short_label
+    end
+
+    def generate_help_text(_model, field_reference, _context)
+      field_reference.help_text
+    end
+
+    def generate_sortable(model, field_reference, context)
+      if generate_sort_by(model, field_reference, context).present?
+        return true
+      end
+
+      field_reference.sortable
+    end
+
+    def generate_sort_by(model, field_reference, _context)
+      Habarico::SortingHelper.descriptor_sort_by(model, field_reference)
+    end
+
+    def generate_read_only(_model, field_reference, _context)
+      field_reference.read_only
+    end
+
+    def generate_write_only(_model, field_reference, _context)
+      field_reference.write_only
+    end
+
+    def generate_default_value(_model, field_reference, _context)
+      field_reference.default_value
+    end
+
+    def generate_action(_model, field_reference, context)
+      return nil unless field_reference.action.present?
+      action_descriptor_generator.generate(field_reference.action, context)
+    end
+
+    def generate_wrapper(_model, field_reference, _context)
+      return nil unless field_reference.wrapper.present?
+      raise Eluvia::Errors::StandardError.new('`wrapper` must be a Habarico::FieldWrapperProperties') unless field_reference.wrapper.is_a?(Habarico::FieldWrapperProperties)
+      field_reference.wrapper
+    end
+
+    def generate_options(model, field_reference, _context)
+      field_options_generator.generate(model, nil, field_reference)
+    end
+
+  end
+end

data/lib/habarico/generators/view/filter_descriptor_generator.rb

@@ -0,0 +1,75 @@
+module Habarico
+  class FilterDescriptorGenerator < AbstractGenerator
+
+    def generate(model, filter_reference, context, force_params = {})
+      # Fallback to a simple FilterReference object if a string or a symbol is provided
+      filter_reference = Habarico::FilterReference.new(name: filter_reference.to_s) if filter_reference.is_a?(String) || filter_reference.is_a?(Symbol)
+
+      # Validate argument
+      raise Eluvia::Errors::StandardError.new('Argument `filter_reference` must be a Habarico::FilterReference') unless filter_reference.is_a?(Habarico::FilterReference)
+
+      # Force parameters
+      filter_reference.assign(force_params)
+
+      # Create model
+      Habarico::FilterDescriptor.new(
+        name: generate_name(model, filter_reference, context),
+        label: generate_label(model, filter_reference, context),
+        help_text: generate_help_text(model, filter_reference, context),
+        is_always_on: generate_is_always_on(model, filter_reference, context),
+        default_value: generate_default_value(model, filter_reference, context),
+      )
+    end
+
+    protected
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_name(_model, field_reference, _context)
+      field_reference.name
+    end
+
+    def generate_label(model, field_reference, _context)
+      return field_reference.label if field_reference.label.present?
+
+      return nil unless model.respond_to?(:filter_params)
+      filter_param = model.filter_params[field_reference.name.to_sym]
+      return nil unless filter_param # In this case do not define label and use the default one from filter schema
+
+      attr_name = filter_param[:attr_name]
+      filters_model_class = filter_param[:model] # this is not the same as `model` argument!
+      i18n_model_class = resolve_i18n_model_class(filters_model_class)
+
+      Habarico::AttributesHelper.generate_attr_variants(filters_model_class, attr_name).each do |attr_name_variant|
+        label = I18n.t("#{i18n_model_class.i18n_scope}.attributes.#{i18n_model_class.model_name.i18n_key}.#{attr_name_variant}", default: nil)
+        return label if label.present?
+      end
+      nil # In this case do not define label and use the default one from filter schema
+    end
+
+    # `filters_model_class` (`filter_param[:model]`) is usually a nested `Eluvia::ActiveRecord::FiltersModel`
+    # proxy class (e.g. `Employee::Filters`), not the real AR model — its own i18n_scope/model_name don't match
+    # where attribute translations actually live. Resolve back to the real model the same way generate_reference
+    # does for class names (strip the `::Filters` suffix), falling back to the proxy class itself if that fails.
+    def resolve_i18n_model_class(filters_model_class)
+      filters_model_class.name.to_s.delete_suffix('::Filters').constantize
+    rescue StandardError
+      filters_model_class
+    end
+
+    def generate_help_text(_model, field_reference, _context)
+      field_reference.help_text
+    end
+
+    def generate_is_always_on(_model, field_reference, _context)
+      field_reference.is_always_on
+    end
+
+    def generate_default_value(_model, field_reference, _context)
+      field_reference.default_value
+    end
+
+  end
+end

data/lib/habarico/generators/view/gallery_box_parameters_generator.rb

@@ -0,0 +1,71 @@
+module Habarico
+  class GalleryBoxParametersGenerator < AbstractGenerator
+
+    def generate(box, context)
+      raise Eluvia::Errors::StandardError.new('Argument `box` must be a Habarico::GalleryBox') unless box.is_a?(Habarico::GalleryBox)
+
+      Habarico::GalleryBoxParameters.new(
+        reference: generate_reference(box, context),
+        target: generate_target(box, context),
+        extra_filters: generate_extra_filters(box, context),
+        filters: generate_filters(box, context),
+        label: generate_label(box, context),
+        image_field: generate_image_field(box, context),
+        default_sorting: generate_default_sorting(box, context),
+        schema_params: generate_schema_params(box, context),
+      )
+    end
+
+    protected
+
+    def filter_descriptor_generator
+      @filter_descriptor_generator ||= definition.filter_descriptor_generator.new(definition, resource_path)
+    end
+
+    def sort_descriptor_generator
+      @sort_descriptor_generator ||= definition.sort_descriptor_generator.new(definition, resource_path)
+    end
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_reference(box, _context)
+      box.reference
+    end
+
+    def generate_target(box, _context)
+      box.target
+    end
+
+    def generate_label(box, _context)
+      box.label
+    end
+
+    def generate_image_field(box, _context)
+      box.image_field
+    end
+
+    def generate_schema_params(box, _context)
+      box.schema_params
+    end
+
+    def generate_extra_filters(box, context)
+      Habarico::CallableHelper.resolve(box.extra_filters, context)
+    end
+
+    def generate_filters(box, context)
+      referenced_model = Habarico::BoxHelper.get_referenced_model(box) || definition.model
+
+      filters = box.filters || []
+      filters.map do |filter|
+        filter_descriptor_generator.generate(referenced_model, filter, context)
+      end
+    end
+
+    def generate_default_sorting(box, context)
+      sort_descriptor_generator.generate(box.default_sorting || Habarico::BoxHelper.get_referenced_definition(box)&.default_sorting, context)
+    end
+
+  end
+end

data/lib/habarico/generators/view/global_view_schema_generator.rb

@@ -0,0 +1,59 @@
+module Habarico
+  class GlobalViewSchemaGenerator < AbstractGenerator
+
+    def generate(view)
+      # Fallback to a simple View object if a string or symbol is provided
+      if view.is_a?(String) || view.is_a?(Symbol)
+        view = case view.to_sym
+               when :list then Habarico::ListView.new
+               when :show then Habarico::ShowView.new
+               when :edit then Habarico::EditView.new
+               when :create then Habarico::CreateView.new
+               end
+      end
+
+      # Validate arguments
+      raise Eluvia::Errors::StandardError.new('Argument `view` must be a Habarico::View') unless view.is_a?(Habarico::View)
+
+      # Create model
+      Habarico::GlobalViewSchema.new(
+        type: generate_type(view),
+        name: generate_name(view),
+        is_detail: generate_is_detail(view),
+        mode: generate_mode(view),
+        endpoint: generate_endpoint(view)
+      )
+    end
+
+    protected
+
+    def view_endpoint_parameters_generator
+      @view_endpoint_parameters_generator ||= definition.view_endpoint_parameters_generator.new(definition, resource_path)
+    end
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_type(view)
+      view.type
+    end
+
+    def generate_name(view)
+      view.name
+    end
+
+    def generate_is_detail(view)
+      view.is_detail.nil? ? view.type.to_sym != :list : view.is_detail
+    end
+
+    def generate_mode(view)
+      view.view_mode
+    end
+
+    def generate_endpoint(view)
+      view_endpoint_parameters_generator.generate(view, Habarico::Context.new)
+    end
+
+  end
+end

data/lib/habarico/generators/view/grid_item_box_parameters_generator.rb

@@ -0,0 +1,44 @@
+module Habarico
+  class GridItemBoxParametersGenerator < AbstractGenerator
+
+    def generate(box, context)
+      # Validate arguments
+      raise Eluvia::Errors::StandardError.new('Argument `box` must be a Habarico::GridItemBox') unless box.is_a?(Habarico::GridItemBox)
+
+      # Create model
+      Habarico::GridItemBoxParameters.new(
+        xs: generate_xs(box, context),
+        sm: generate_sm(box, context),
+        md: generate_md(box, context),
+        lg: generate_lg(box, context),
+        xl: generate_xl(box, context),
+      )
+    end
+
+    protected
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_xs(box, _context)
+      box.xs
+    end
+
+    def generate_sm(box, _context)
+      box.sm
+    end
+
+    def generate_md(box, _context)
+      box.md
+    end
+
+    def generate_lg(box, _context)
+      box.lg
+    end
+
+    def generate_xl(box, _context)
+      box.xl
+    end
+  end
+end

data/lib/habarico/generators/view/list_box_parameters_generator.rb

@@ -0,0 +1,124 @@
+module Habarico
+  class ListBoxParametersGenerator < AbstractGenerator
+
+    def generate(box, context)
+      # Validate arguments
+      raise Eluvia::Errors::StandardError.new('Argument `box` must be a Habarico::ListBox') unless box.is_a?(Habarico::ListBox)
+      raise Eluvia::Errors::StandardError.new('Attributes `reference` of the `box` argument must be set') if box.reference.blank?
+      raise Eluvia::Errors::StandardError.new('Attributes `target` or `extra_filters` of the `box` argument must be set') if box.target.blank? && box.extra_filters.blank?
+
+      # Create model
+      Habarico::ListBoxParameters.new(
+        reference: generate_reference(box, context),
+        target: generate_target(box, context),
+        extra_filters: generate_extra_filters(box, context),
+        filters: generate_filters(box, context),
+        row_actions: generate_row_actions(box, context),
+        toolbar_actions: generate_toolbar_actions(box, context),
+        list_actions: generate_list_actions(box, context),
+        default_sorting: generate_default_sorting(box, context),
+        sortable: generate_sortable(box, context),
+        schema_params: generate_schema_params(box, context),
+        single_click_action: generate_single_click_action(box, context),
+        double_click_action: generate_double_click_action(box, context),
+      )
+    end
+
+    protected
+
+    def filter_descriptor_generator
+      @filter_descriptor_generator ||= definition.filter_descriptor_generator.new(definition, resource_path)
+    end
+
+    def sort_descriptor_generator
+      @sort_descriptor_generator ||= definition.sort_descriptor_generator.new(definition, resource_path)
+    end
+
+    def action_descriptor_generator
+      @action_descriptor_generator ||= definition.action_descriptor_generator.new(definition, resource_path)
+    end
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_reference(box, _context)
+      box.reference
+    end
+
+    def generate_target(box, _context)
+      box.target
+    end
+
+    def generate_extra_filters(box, context)
+      Habarico::CallableHelper.resolve(box.extra_filters, context)
+    end
+
+    def generate_filters(box, context)
+      referenced_model = Habarico::BoxHelper.get_referenced_model(box) || definition.model
+
+      # Generate filter descriptors
+      filters = box.filters || []
+      filters.map do |filter|
+        filter_descriptor_generator.generate(referenced_model, filter, context)
+      end
+    end
+
+    def generate_row_actions(box, context)
+      unless box.row_actions.nil?
+        return box.row_actions.map do |action|
+          action_descriptor_generator.generate(action, context)
+        end.compact
+      end
+      nil
+    end
+
+    # Table's own toolbar (top of the resource list, e.g. create). Fed by the ListBox's `list_toolbar_actions`,
+    # separate from the box-level `toolbar_actions` which is emitted at the box root.
+    def generate_toolbar_actions(box, context)
+      unless box.list_toolbar_actions.nil?
+        return box.list_toolbar_actions.map do |action|
+          action_descriptor_generator.generate(action, context)
+        end.compact
+      end
+      nil
+    end
+
+    # Utility actions of the table (export, print, ...) rendered next to the filter bar.
+    def generate_list_actions(box, context)
+      unless box.list_actions.nil?
+        return box.list_actions.map do |action|
+          action_descriptor_generator.generate(action, context)
+        end.compact
+      end
+      nil
+    end
+
+    def generate_default_sorting(box, context)
+      sort_descriptor_generator.generate(box.default_sorting || Habarico::BoxHelper.get_referenced_definition(box)&.default_sorting, context)
+    end
+
+    def generate_sortable(box, _context)
+      return nil unless box.sortable_field_name.present?
+      Habarico::SortableParameters.new(
+        field_name: box.sortable_field_name,
+        sort_for_filters: box.sortable_sort_for_filters,
+      )
+    end
+
+    def generate_schema_params(box, _context)
+      box.schema_params
+    end
+
+    def generate_single_click_action(box, context)
+      return nil if box.single_click_action.nil?
+      action_descriptor_generator.generate(box.single_click_action, context)
+    end
+
+    def generate_double_click_action(box, context)
+      return nil if box.double_click_action.nil?
+      action_descriptor_generator.generate(box.double_click_action, context)
+    end
+
+  end
+end

data/lib/habarico/generators/view/list_view_parameters_generator.rb

@@ -0,0 +1,120 @@
+module Habarico
+  class ListViewParametersGenerator < AbstractGenerator
+
+    def generate(view, context)
+      # Validate arguments
+      raise Eluvia::Errors::StandardError.new('Argument `view` must be a Habarico::View') unless view.is_a?(Habarico::View)
+
+      # Create model
+      Habarico::ListViewParameters.new(
+        boxes: generate_boxes(view, context),
+        filters: generate_filters(view, context),
+        row_actions: generate_row_actions(view, context),
+        toolbar_actions: generate_toolbar_actions(view, context),
+        list_actions: generate_list_actions(view, context),
+        default_sorting: generate_default_sorting(view, context),
+        single_click_action: generate_single_click_action(view, context),
+        double_click_action: generate_double_click_action(view, context),
+      )
+    end
+
+    protected
+
+    def field_descriptor_generator
+      @field_descriptor_generator ||= definition.field_descriptor_generator.new(definition, resource_path)
+    end
+
+    def filter_descriptor_generator
+      @filter_descriptor_generator ||= definition.filter_descriptor_generator.new(definition, resource_path)
+    end
+
+    def sort_descriptor_generator
+      @sort_descriptor_generator ||= definition.sort_descriptor_generator.new(definition, resource_path)
+    end
+
+    def action_descriptor_generator
+      @action_descriptor_generator ||= definition.action_descriptor_generator.new(definition, resource_path)
+    end
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_boxes(view, context)
+      boxes = view.boxes
+      return nil if boxes.nil? || boxes.empty?
+      boxes.map do |field|
+        field_descriptor_generator.generate(definition.model, field, context)
+      end
+    end
+
+    def generate_filters(view, context)
+      # Toolbar filters (always-on). These take precedence: any standard filter with the
+      # same name is dropped below so a filter is never rendered twice.
+      toolbar_filters = (view.respond_to?(:toolbar_filters) ? view.toolbar_filters : nil) || []
+      toolbar_names = toolbar_filters.map { |filter| filter_reference_name(filter) }
+
+      # Standard (drawer) filters, falling back to the definition-level filter set. Exclude
+      # anything already promoted to the toolbar to avoid duplicates.
+      standard_filters = (view.respond_to?(:filters) ? view.filters : nil) || definition.filters || []
+      standard_filters = standard_filters.reject { |filter| toolbar_names.include?(filter_reference_name(filter)) }
+
+      toolbar_descriptors = toolbar_filters.map do |filter|
+        filter_descriptor_generator.generate(definition.model, filter, context, is_always_on: true)
+      end
+      standard_descriptors = standard_filters.map do |filter|
+        filter_descriptor_generator.generate(definition.model, filter, context)
+      end
+
+      toolbar_descriptors + standard_descriptors
+    end
+
+    # Normalize a filter entry (Symbol, String or FilterReference) to its name for comparison.
+    def filter_reference_name(filter)
+      filter.is_a?(Habarico::FilterReference) ? filter.name.to_s : filter.to_s
+    end
+
+    def generate_row_actions(view, context)
+      unless view.row_actions.nil?
+        return view.row_actions.map do |action|
+          action_descriptor_generator.generate(action, context)
+        end.compact
+      end
+      nil
+    end
+
+    def generate_toolbar_actions(view, context)
+      unless view.toolbar_actions.nil?
+        return view.toolbar_actions.map do |action|
+          action_descriptor_generator.generate(action, context)
+        end.compact
+      end
+      nil
+    end
+
+    # Utility actions of the table (export, print, ...) rendered next to the filter bar.
+    def generate_list_actions(view, context)
+      unless view.list_actions.nil?
+        return view.list_actions.map do |action|
+          action_descriptor_generator.generate(action, context)
+        end.compact
+      end
+      nil
+    end
+
+    def generate_default_sorting(view, context)
+      sort_descriptor_generator.generate(view.default_sorting || definition.default_sorting, context)
+    end
+
+    def generate_single_click_action(view, context)
+      return nil if view.single_click_action.nil?
+      action_descriptor_generator.generate(view.single_click_action, context)
+    end
+
+    def generate_double_click_action(view, context)
+      return nil if view.double_click_action.nil?
+      action_descriptor_generator.generate(view.double_click_action, context)
+    end
+
+  end
+end

data/lib/habarico/generators/view/object_box_parameters_generator.rb

@@ -0,0 +1,26 @@
+module Habarico
+  class ObjectBoxParametersGenerator < AbstractGenerator
+
+    def generate(box, context)
+      # Validate arguments
+      raise Eluvia::Errors::StandardError.new('Argument `box` must be a Habarico::ObjectBox') unless box.is_a?(Habarico::ObjectBox)
+      raise Eluvia::Errors::StandardError.new('Attribute `target` of the `box` argument must be set') if box.target.blank?
+
+      # Create model
+      Habarico::ObjectBoxParameters.new(
+        target: generate_target(box, context)
+      )
+    end
+
+    protected
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_target(box, _context)
+      box.target
+    end
+
+  end
+end

data/lib/habarico/generators/view/sort_descriptor_generator.rb

@@ -0,0 +1,30 @@
+module Habarico
+  class SortDescriptorGenerator < AbstractGenerator
+
+    def generate(sort_descriptor, context)
+      # Nothing declared, nothing published - the frontend then sorts by the primary key, which is
+      # what the backend orders by too (HAB-915).
+      return nil if sort_descriptor.blank?
+
+      Habarico::SortDescriptor.new(
+        field_name: generate_field_name(sort_descriptor, context),
+        direction: generate_direction(sort_descriptor, context),
+      )
+    end
+
+    protected
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_field_name(sort_descriptor, _context)
+      Habarico::OrderByHelper.field_name(sort_descriptor)
+    end
+
+    def generate_direction(sort_descriptor, _context)
+      Habarico::OrderByHelper.direction(sort_descriptor)
+    end
+
+  end
+end

data/lib/habarico/generators/view/tab_box_parameters_generator.rb

@@ -0,0 +1,26 @@
+module Habarico
+  class TabBoxParametersGenerator < AbstractGenerator
+
+    def generate(box, context)
+      # Validate arguments
+      raise Eluvia::Errors::StandardError.new('Argument `box` must be a Habarico::TabBox') unless box.is_a?(Habarico::TabBox)
+
+      # Create model
+      Habarico::TabBoxParameters.new(
+        show_toolbar_navigation: generate_show_toolbar_navigation(box, context),
+      )
+    end
+
+    protected
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    # Defaults to false for tab boxes.
+    def generate_show_toolbar_navigation(box, _context)
+      box.show_toolbar_navigation.nil? ? false : !!box.show_toolbar_navigation
+    end
+
+  end
+end