habarico 7.2.0.pre.beta.5

data/lib/habarico/generators/resource/local_resource_schema_generator.rb

@@ -0,0 +1,111 @@
+module Habarico
+  class LocalResourceSchemaGenerator < ResourceSchemaGenerator
+
+    def generate(context)
+      actions, actions_endpoint_parameters = generate_actions(context)
+      views, views_endpoint_parameters = generate_views(context)
+      Habarico::LocalResourceSchema.new(
+        name: generate_name,
+        label: generate_label,
+        pk_field_name: generate_pk_field_name,
+        actions: actions,
+        views: views,
+        endpoints: generate_endpoints(context, actions_endpoint_parameters + views_endpoint_parameters)
+      )
+    end
+
+    protected
+
+    def resource_action_schema_generator
+      @resource_action_schema_generator ||= definition.resource_action_schema_generator.new(definition, resource_path)
+    end
+
+    def view_schema_generator
+      @view_schema_generator ||= definition.view_schema_generator.new(definition, resource_path)
+    end
+
+    def endpoints_schema_generator
+      @endpoints_schema_generator ||= definition.endpoints_schema_generator.new(definition, resource_path)
+    end
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_actions(context)
+      is_detail = !context.record_pk.blank?
+
+      # Generate and filter actions based on permissions and whether we are generating for detail or list
+      action_schemas = definition.normalized_actions.select do |action|
+
+        # Action must be allowed by permissions
+        context.can?(action.permission)
+
+      end.map do |action|
+
+        # Generate action schema
+        resource_action_schema_generator.generate(action, context)
+
+      end.select do |action_schema|
+
+        # Plausibility check, only actions that are shown in the current context should be included here
+        (is_detail && action_schema.show_in_detail) || # we generate record/detail schema and action should be shown in detail
+          (!is_detail && action_schema.show_in_list && !action_schema.is_detail) # we generate resource/list schema and action should be shown in list and does not require record PK
+
+      end
+
+      # Extract endpoint parameters from actions
+      endpoint_parameters = action_schemas.map { |action_schema| action_schema&.resource&.endpoint }.compact
+
+      [action_schemas, endpoint_parameters]
+    end
+
+    def generate_views(context)
+      is_detail = !context.record_pk.blank?
+
+      # Generate and filter views based on permissions and whether we are generating for detail or list
+      view_schemas = definition.normalized_views.select do |view|
+
+        # View must be allowed by permissions, only exception is the show view in order to support references across
+        # multiple services.
+        (view.name.to_s == 'show' && is_detail) || context.can?(view.permission)
+
+      end.map do |view|
+
+        # Generate view schema
+        view_schema_generator.generate(view, context)
+
+      end.select do |view_schema|
+
+        # Plausibility check, only views that are shown in the current context should be included here
+        view_schema.is_detail == is_detail
+
+      end
+
+      # Extract endpoint parameters from views
+      endpoint_parameters = view_schemas.map { |view_schema| view_schema&.endpoint }.compact
+
+      [view_schemas, endpoint_parameters]
+    end
+
+    def generate_endpoints(_context, endpoint_parameters)
+      # Determine endpoint methods to be included, base for the selection ale endpoint parameters collected from the
+      # actions and views without action name and without reference. Additionally, always include GET.
+      methods = endpoint_parameters.select { |e| e.action_name.blank? && e.reference.blank? }.map { |e| e.method.to_sym }
+      methods << :get # Ensure GET is always present
+      methods = methods.uniq
+
+      # Determine read and write fields
+      read_fields = (definition.fields + definition.read_only_fields).uniq
+      write_fields = (definition.fields + definition.write_only_fields).uniq
+
+      # Generate endpoint schema
+      endpoints_schema_generator.generate(definition.model,
+                                         read_fields,
+                                         write_fields,
+                                         definition.filters,
+                                         methods)
+    end
+
+  end
+end

data/lib/habarico/generators/resource/object_resource_schema_generator.rb

@@ -0,0 +1,49 @@
+module Habarico
+  class ObjectResourceSchemaGenerator < ResourceSchemaGenerator
+
+    def generate(view_type, context)
+      Habarico::ObjectResourceSchema.new(
+        name: generate_name,
+        label: generate_label,
+        pk_field_name: generate_pk_field_name,
+        actions: generate_actions(view_type, context),
+      )
+    end
+
+    protected
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_actions(_view_type, context)
+      action_schemas = definition.normalized_actions.select do |action|
+
+        # Action must be allowed by permissions
+        context.can?(action.permission)
+
+      end.select do |action|
+
+        # Conditional display check
+        if action.if.respond_to?(:call)
+          action.if.call(context)
+        else
+          true
+        end
+
+      end.map do |action|
+
+        # Generate action schema
+        resource_action_schema_generator.generate(action, context)
+
+      end
+
+      # Object-level meta always represents detail semantics, regardless of which endpoint
+      # (list or detail) is rendering it, so that a record's action list is identical no
+      # matter which response it came from. Only record-bound actions belong here; actions
+      # that aren't tied to a specific record (e.g. create) are excluded via is_detail.
+      action_schemas.select(&:is_detail)
+    end
+
+  end
+end

data/lib/habarico/generators/resource/resource_schema_generator.rb

@@ -0,0 +1,31 @@
+module Habarico
+  class ResourceSchemaGenerator < AbstractGenerator
+
+    def generate
+      raise NotImplementedError('Subclasses must implement the generate method.')
+    end
+
+    protected
+
+    def resource_action_schema_generator
+      @resource_action_schema_generator ||= definition.resource_action_schema_generator.new(definition, resource_path)
+    end
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_name
+      resource_path.last
+    end
+
+    def generate_label
+      definition.label || I18n.t("resources.#{resource_path.join('.')}", default: generate_name.to_s.humanize)
+    end
+
+    def generate_pk_field_name
+      definition.model.primary_key
+    end
+
+  end
+end

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

@@ -0,0 +1,88 @@
+module Habarico
+  class ActionDescriptorGenerator < AbstractGenerator
+
+    def generate(action_reference, context)
+      # Fallback to a simple ActionReference object if a string or symbol is provided
+      action_reference = Habarico::ActionReference.new(name: action_reference.to_s) if action_reference.is_a?(String) || action_reference.is_a?(Symbol)
+
+      # Validate arguments
+      raise Eluvia::Errors::StandardError.new('Argument `action_reference` must be a Habarico::ActionReference') unless action_reference.is_a?(Habarico::ActionReference)
+
+      # Check permission
+      if action_reference.permission.present?
+        return nil unless context.can?(action_reference.permission)
+      end
+
+      # Check "if" condition
+      if action_reference.if.present?
+        return nil unless Habarico::CallableHelper.resolve(action_reference.if, context)
+      end
+
+      # Create model
+      Habarico::ActionDescriptor.new(
+        name: generate_name(action_reference, context),
+        label: generate_label(action_reference, context),
+        icon: generate_icon(action_reference, context),
+        color: generate_color(action_reference, context),
+        action: generate_action(action_reference, context),
+        view: generate_view(action_reference, context),
+        menu_items: generate_menu_items(action_reference, context),
+      )
+    end
+
+    protected
+
+    def action_schema_generator
+      @action_schema_generator ||= definition.action_schema_generator.new(definition, resource_path)
+    end
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_name(action_reference, _context)
+      action_reference.name
+    end
+
+    def generate_label(action_reference, _context)
+      action_reference.label
+    end
+
+    def generate_icon(action_reference, _context)
+      action_reference.icon
+    end
+
+    def generate_color(action_reference, _context)
+      action_reference.color
+    end
+
+    def generate_action(action_reference, context)
+      if action_reference.action.present?
+        return action_schema_generator.generate(action_reference.action, context)
+      end
+      nil
+    end
+
+    def generate_view(action_reference, _context)
+      has_view_params = action_reference.view_mode.present? ||
+                        action_reference.view_choices.present? ||
+                        action_reference.view_parameters.present? ||
+                        !action_reference.view_keep_linked_parent.nil?
+      return nil unless has_view_params
+      Habarico::ViewActionDescriptorParameters.new(
+        mode: action_reference.view_mode,
+        choices: action_reference.view_choices,
+        parameters: action_reference.view_parameters,
+        keep_linked_parent: action_reference.view_keep_linked_parent,
+      )
+    end
+
+    def generate_menu_items(action_reference, context)
+      return nil unless action_reference.menu_items.present?
+      action_reference.menu_items.map do |item|
+        generate(item, context)
+      end.compact
+    end
+
+  end
+end

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

@@ -0,0 +1,34 @@
+module Habarico
+  class ArrayBoxParametersGenerator < AbstractGenerator
+
+    def generate(box, context)
+      # Validate arguments
+      raise Eluvia::Errors::StandardError.new('Argument `box` must be a Habarico::ArrayBox') unless box.is_a?(Habarico::ArrayBox)
+
+      # Create model
+      Habarico::ArrayBoxParameters.new(
+        target: generate_target(box, context),
+        inline: generate_inline(box, context)
+      )
+    end
+
+    protected
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_target(box, _context)
+      box.target
+    end
+
+    # Defaults to true unless the box contains nested boxes (then the items are rendered as separate blocks).
+    # An explicit `inline` value on the box always wins.
+    def generate_inline(box, _context)
+      return !!box.inline unless box.inline.nil?
+      boxes = box.boxes || []
+      boxes.none? { |item| item.is_a?(Habarico::Box) }
+    end
+
+  end
+end

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

@@ -0,0 +1,23 @@
+module Habarico
+  class BoxOptionsGenerator < AbstractGenerator
+
+    def generate(box)
+      Habarico::BoxOptions.new(
+        dynamic_render: generate_dynamic_render(box)
+      )
+    end
+
+    protected
+
+    def generate_dynamic_render(box)
+      dynamic_render_options_generator.generate(definition.model, box)
+    end
+
+    private
+
+    def dynamic_render_options_generator
+      @dynamic_render_options_generator ||= definition.dynamic_render_options_generator.new(definition, resource_path)
+    end
+
+  end
+end

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

@@ -0,0 +1,194 @@
+module Habarico
+  class BoxSchemaGenerator < AbstractGenerator
+
+    def generate(view, box, index, context)
+      # Fallback to an empty box if none is provided
+      box = Habarico::Box.new if box.nil?
+
+      # Validate arguments
+      raise Eluvia::Errors::StandardError.new('Argument `view` must be a Habarico::View') unless view.is_a?(Habarico::View)
+      raise Eluvia::Errors::StandardError.new('Argument `box` must be a Habarico::Box') unless box.is_a?(Habarico::Box)
+
+      # Deduce reference and target for has_many associations for list boxes
+      if box.type == 'list' && !box.reference
+        if box.name && Habarico::ReflectionHelper.is_has_many_association?(definition.model, box.name)
+          reflection = definition.model.reflect_on_association(box.name.to_sym)
+          if reflection
+            reference = Habarico::ResourceService.instance.find_resource_name_by_model_class(reflection.klass)
+            if reference
+              box.reference = reference
+              box.target = reflection.foreign_key
+            end
+          end
+        end
+      end
+
+      # Create model
+      Habarico::BoxSchema.new(
+        type: generate_type(view, box, index, context),
+        name: generate_name(view, box, index, context),
+        label: generate_label(view, box, index, context),
+        read_only: generate_read_only(view, box, index, context),
+        card: generate_card(view, box, index, context),
+        collapsible: generate_collapsible(view, box, index, context),
+        toolbar_actions: generate_toolbar_actions(view, box, index, context),
+        bottom_actions: generate_bottom_actions(view, box, index, context),
+        boxes: generate_boxes(view, box, index, context),
+        grid_item: generate_grid_item(view, box, index, context),
+        list: generate_list(view, box, index, context),
+        tab: generate_tab(view, box, index, context),
+        wizard: generate_wizard(view, box, index, context),
+        array: generate_array(view, box, index, context),
+        object: generate_object(view, box, index, context),
+        gallery: generate_gallery(view, box, index, context),
+        options: generate_options(view, box, index, context)
+      )
+    end
+
+    protected
+
+    def field_descriptor_generator
+      @field_descriptor_generator ||= definition.field_descriptor_generator.new(definition, resource_path)
+    end
+
+    def box_schema_generator
+      @box_schema_generator ||= definition.box_schema_generator.new(definition, resource_path)
+    end
+
+    def array_box_parameters_generator
+      @array_box_parameters_generator ||= definition.array_box_parameters_generator.new(definition, resource_path)
+    end
+
+    def object_box_parameters_generator
+      @object_box_parameters_generator ||= definition.object_box_parameters_generator.new(definition, resource_path)
+    end
+
+    def grid_item_box_parameters_generator
+      @grid_item_box_parameters_generator ||= definition.grid_item_box_parameters_generator.new(definition, resource_path)
+    end
+
+    def list_box_parameters_generator
+      @list_box_parameters_generator ||= definition.list_box_parameters_generator.new(definition, resource_path)
+    end
+
+    def tab_box_parameters_generator
+      @tab_box_parameters_generator ||= definition.tab_box_parameters_generator.new(definition, resource_path)
+    end
+
+    def wizard_box_parameters_generator
+      @wizard_box_parameters_generator ||= definition.wizard_box_parameters_generator.new(definition, resource_path)
+    end
+
+    def gallery_box_parameters_generator
+      @gallery_box_parameters_generator ||= definition.gallery_box_parameters_generator.new(definition, resource_path)
+    end
+
+    def action_descriptor_generator
+      @action_descriptor_generator ||= definition.action_descriptor_generator.new(definition, resource_path)
+    end
+
+    def box_options_generator
+      @box_options_generator ||= definition.box_options_generator.new(definition, resource_path)
+    end
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_type(_view, box, _index, _context)
+      box.type
+    end
+
+    def generate_name(_view, box, index, _context)
+      box.name || index.to_s
+    end
+
+    def generate_label(_view, box, _index, _context)
+      box.label
+    end
+
+    def generate_read_only(_view, box, _index, _context)
+      !!box.read_only
+    end
+
+    # Three-state on purpose: true (always a card), false (never a card, not even with a label)
+    # and nil (unset - the frontend decides from the label, the toolbar actions and the surface).
+    # Coercing nil to false here would strip the card off every labelled box.
+    def generate_card(_view, box, _index, _context)
+      box.card
+    end
+
+    def generate_collapsible(_view, box, _index, _context)
+      box.collapsible&.to_s
+    end
+
+    # Box-level toolbar (box header / card header area), relative to the box root. Emitted for all box types
+    # including 'list' - for a list box the table's own toolbar is carried separately by 'list.toolbar_actions'.
+    def generate_toolbar_actions(_view, box, _index, context)
+      return nil if box.toolbar_actions.nil?
+      box.toolbar_actions.map do |action|
+        action_descriptor_generator.generate(action, context)
+      end.compact
+    end
+
+    # Box-level bottom actions (rendered below the box fields), relative to the box root.
+    def generate_bottom_actions(_view, box, _index, context)
+      return nil if box.bottom_actions.nil?
+      box.bottom_actions.map do |action|
+        action_descriptor_generator.generate(action, context)
+      end.compact
+    end
+
+    def generate_boxes(view, box, _index, context)
+      referenced_model = Habarico::BoxHelper.get_referenced_model(box) || definition.model
+      boxes = box.boxes || view.boxes
+      return nil if boxes.nil? || boxes.empty?
+      boxes.enum_for(:each_with_index).map do |item, i|
+        if item.is_a?(Habarico::Box)
+          box_schema_generator.generate(view, item, i, context)
+        else
+          field_descriptor_generator.generate(referenced_model, item, context)
+        end
+      end
+    end
+
+    def generate_grid_item(_view, box, _index, context)
+      return nil unless box.type == 'grid-item'
+      grid_item_box_parameters_generator.generate(box, context)
+    end
+
+    def generate_list(_view, box, _index, context)
+      return nil unless box.type == 'list'
+      list_box_parameters_generator.generate(box, context)
+    end
+
+    def generate_tab(_view, box, _index, context)
+      return nil unless box.type == 'tab'
+      tab_box_parameters_generator.generate(box, context)
+    end
+
+    def generate_wizard(_view, box, _index, context)
+      return nil unless box.type == 'wizard'
+      wizard_box_parameters_generator.generate(box, context)
+    end
+
+    def generate_array(_view, box, _index, context)
+      return nil unless box.type == 'array'
+      array_box_parameters_generator.generate(box, context)
+    end
+
+    def generate_object(_view, box, _index, context)
+      return nil unless box.type == 'object'
+      object_box_parameters_generator.generate(box, context)
+    end
+
+    def generate_gallery(_view, box, _index, context)
+      return nil unless box.type == 'gallery'
+      gallery_box_parameters_generator.generate(box, context)
+    end
+
+    def generate_options(_view, box, _index, _context)
+      box_options_generator.generate(box)
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Habarico
+  class DetailViewParametersGenerator < 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::DetailViewParameters.new(
+        box: generate_box(view, context),
+        toolbar_actions: generate_toolbar_actions(view, context),
+        bottom_actions: generate_bottom_actions(view, context),
+      )
+    end
+
+    BOTTOM_ACTION_VIEW_TYPES = %i[create edit action].freeze
+
+    protected
+
+    def box_schema_generator
+      @box_schema_generator ||= definition.box_schema_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_box(view, context)
+      box_schema_generator.generate(view, view.box, 0, context)
+    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
+
+    def generate_bottom_actions(view, context)
+      if BOTTOM_ACTION_VIEW_TYPES.include?(view.type.to_sym)
+        save_reference = Habarico::ActionReference.new(
+          name: 'save',
+          permission: nil,
+          action: Habarico::SaveAction.new
+        )
+        [action_descriptor_generator.generate(save_reference, context)].compact
+      end
+    end
+
+  end
+end