habarico 7.2.0.pre.beta.5

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

@@ -0,0 +1,71 @@
+module Habarico
+  class ViewEndpointParametersGenerator < 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::ViewEndpointParameters.new(
+        path: generate_path(view, context),
+        method: generate_method(view, context),
+        reference: generate_reference(view, context),
+        action_name: generate_action_name(view, context)
+      )
+    end
+
+    protected
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_path(view, context)
+      # Standard views (list, show, create, edit) are served from the standard resource path, which the
+      # frontend derives on its own; only action views need an explicit path.
+      return nil if view.endpoint_action_name.blank?
+
+      url_prefix = Habarico::Config.routing_url_prefix.trim('/')
+      result = !url_prefix.blank? ? "/#{url_prefix}" : ''
+
+      # Add resource path
+      reference = generate_reference(view, context)
+      if reference.present?
+        resource_path_2 = ResourceService.instance.get_resource_path(reference)
+        result += "/#{resource_path_2.join('/')}"
+      else
+        result += "/#{resource_path.join('/')}"
+      end
+
+      # Add record PK
+      record_pk = generate_record_pk(view, context)
+      result += "/#{record_pk}" if record_pk
+
+      # Add action name
+      action_name = generate_action_name(view, context)
+      result += "/#{action_name}" if action_name
+
+      # Return result
+      "#{result}/"
+    end
+
+    def generate_method(view, _context)
+      view.endpoint_method
+    end
+
+    def generate_reference(view, _context)
+      view.endpoint_reference
+    end
+
+    def generate_action_name(view, _context)
+      view.endpoint_action_name
+    end
+
+    def generate_record_pk(view, context)
+      if view.is_detail
+        context.record_pk
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,87 @@
+module Habarico
+  class ViewSchemaGenerator < 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::ViewSchema.new(
+        type: generate_type(view, context),
+        name: generate_name(view, context),
+        label: generate_label(view, context),
+        is_detail: generate_is_detail(view, context),
+        list: generate_list(view, context),
+        detail: generate_detail(view, context),
+        endpoint: generate_endpoint(view, context),
+        breadcrumbs: generate_breadcrumbs(view, context),
+      )
+    end
+
+    protected
+
+    def list_view_parameters_generator
+      @list_view_parameters_generator ||= definition.list_view_parameters_generator.new(definition, resource_path)
+    end
+
+    def detail_view_parameters_generator
+      @detail_view_parameters_generator ||= definition.detail_view_parameters_generator.new(definition, resource_path)
+    end
+
+    def view_endpoint_parameters_generator
+      @view_endpoint_parameters_generator ||= definition.view_endpoint_parameters_generator.new(definition, resource_path)
+    end
+
+    def menu_schema_generator
+      @menu_schema_generator ||= definition.menu_schema_generator.new(definition, resource_path)
+    end
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    def generate_type(view, _context)
+      view.type
+    end
+
+    def generate_name(view, _context)
+      view.name
+    end
+
+    def generate_label(view, context)
+      view_name = generate_name(view, context).to_s
+      view.label ||
+        I18n.t("views.#{resource_path.join('.')}.#{view_name}", default: nil) ||
+        I18n.t("views.common.#{view_name}", default: nil)
+    end
+
+    def generate_is_detail(view, _context)
+      !!view.is_detail
+    end
+
+    def generate_list(view, context)
+      if view.type == :list
+        list_view_parameters_generator.generate(view, context)
+      end
+    end
+
+    def generate_detail(view, context)
+      unless view.type == :list
+        detail_view_parameters_generator.generate(view, context)
+      end
+    end
+
+    def generate_endpoint(view, context)
+      view_endpoint_parameters_generator.generate(view, context)
+    end
+
+    def generate_breadcrumbs(view, context)
+      if definition.breadcrumbs&.respond_to?(:call)
+        definition.breadcrumbs.call(view, context).map do |menu_item|
+          menu_schema_generator.generate(menu_item, nil)
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,32 @@
+module Habarico
+  class WizardBoxParametersGenerator < AbstractGenerator
+
+    def generate(box, context)
+      # Validate arguments
+      raise Eluvia::Errors::StandardError.new('Argument `box` must be a Habarico::WizardBox') unless box.is_a?(Habarico::WizardBox)
+
+      # Create model
+      Habarico::WizardBoxParameters.new(
+        show_toolbar_navigation: generate_show_toolbar_navigation(box, context),
+        validate_steps: generate_validate_steps(box, context),
+      )
+    end
+
+    protected
+
+    # ***********************************************************************
+    # Attribute generators
+    # ***********************************************************************
+
+    # Defaults to true for wizard boxes.
+    def generate_show_toolbar_navigation(box, _context)
+      box.show_toolbar_navigation.nil? || !!box.show_toolbar_navigation
+    end
+
+    # Defaults to true.
+    def generate_validate_steps(box, _context)
+      box.validate_steps.nil? || !!box.validate_steps
+    end
+
+  end
+end

data/lib/habarico/helpers/action_helper.rb

@@ -0,0 +1,9 @@
+module Habarico
+  module ActionHelper
+
+    def self.is_standard_action?(action)
+      %w[show create update delete].include?(action.name)
+    end
+
+  end
+end

data/lib/habarico/helpers/attributes_helper.rb

@@ -0,0 +1,67 @@
+module Habarico
+  module AttributesHelper
+
+    # Extracts the underlying attribute name from a field entry as it may appear in `fields` /
+    # `read_only_fields`: a Symbol/String, a Hash (`{ name => subfields }`) or a FieldReference.
+    def self.field_name(field)
+      case field
+      when Habarico::FieldReference then field.name.to_s
+      when ::Hash then field.keys.first.to_s
+      else field.to_s
+      end
+    end
+
+    # FieldSchema attributes a FieldReference (used in `fields` / `read_only_fields`) may override.
+    FIELD_REFERENCE_OVERRIDES = %i[format label short_label help_text read_only write_only sortable sort_by default_value].freeze
+
+    # Applies a FieldReference's explicitly set attributes onto a generated FieldSchema, overriding
+    # the model-derived defaults. A `nil` FieldReference (Symbol/String/Hash field) is a no-op.
+    def self.apply_field_reference_overrides(schema, field_reference)
+      return schema if field_reference.nil?
+
+      FIELD_REFERENCE_OVERRIDES.each do |attr|
+        value = field_reference.public_send(attr)
+        schema.public_send("#{attr}=", value) unless value.nil?
+      end
+      schema
+    end
+
+    def self.is_amount_major_attr?(model, attr_name)
+      attr_name.to_s.end_with?('_major') && model.respond_to?(:has_amount_attr?) && model.has_amount_attr?(attr_name.to_s.sub(/_major\z/, ''))
+    end
+
+    def self.is_amount_minor_attr?(model, attr_name)
+      attr_name.to_s.end_with?('_minor') && model.respond_to?(:has_amount_attr?) && model.has_amount_attr?(attr_name.to_s.sub(/_minor\z/, ''))
+    end
+
+    def self.is_enum_obj_attr?(model, attr_name)
+      attr_name.to_s.end_with?('_obj') && model.respond_to?(:has_enum_attr?) && model.has_enum_attr?(attr_name.to_s.sub(/_obj\z/, ''))
+    end
+
+    def self.generate_attr_variants(model, attr_name)
+      attr_name = attr_name.to_s
+
+      # Amount
+      if is_amount_major_attr?(model, attr_name)
+        return [attr_name.sub(/_major\z/, ''), attr_name, attr_name.sub(/_major\z/, '_minor')]
+      end
+      if is_amount_minor_attr?(model, attr_name)
+        return [attr_name.sub(/_minor\z/, ''), attr_name, attr_name.sub(/_minor\z/, '_major')]
+      end
+      if model.respond_to?(:has_amount_attr?) && model.has_amount_attr?(attr_name)
+        return [attr_name, "#{attr_name}_major", "#{attr_name}_minor"]
+      end
+
+      # Enum
+      if is_enum_obj_attr?(model, attr_name)
+        return [attr_name.sub(/_obj\z/, ''), attr_name]
+      end
+      if model.respond_to?(:has_enum_attr?) && model.has_enum_attr?(attr_name)
+        return [attr_name, "#{attr_name}_obj"]
+      end
+
+      [attr_name]
+    end
+
+  end
+end

data/lib/habarico/helpers/box_helper.rb

@@ -0,0 +1,19 @@
+module Habarico
+  module BoxHelper
+    def self.get_referenced_definition(box)
+      if box.reference
+        return Habarico::ResourceService.instance.get_definition(Habarico::ResourceService.instance.get_resource_path(box.reference))
+      end
+      nil
+    end
+
+    def self.get_referenced_model(box)
+      referenced_definition = get_referenced_definition(box)
+      if referenced_definition
+        return referenced_definition.model
+      end
+      nil
+    end
+
+  end
+end

data/lib/habarico/helpers/callable_helper.rb

@@ -0,0 +1,15 @@
+module Habarico
+  module CallableHelper
+
+    def self.resolve(callable_or_value, context)
+      if callable_or_value.respond_to?(:call)
+        callable_or_value.call(context)
+      elsif callable_or_value.is_a?(::String)
+        callable_or_value.to_s.sub(/{id}/, context.record_pk.to_s)
+      else
+        callable_or_value
+      end
+    end
+
+  end
+end

data/lib/habarico/helpers/filter_params_helper.rb

@@ -0,0 +1,49 @@
+module Habarico
+  # Parsing of the list-endpoint filter params. A named term can arrive either as a direct param
+  # (`{ search: 'x' }`) or embedded in the `:filter` string as a `&`-separated `field=<json>`
+  # term (`{ filter: 'search="x"&status="y"' }`). These helpers read or remove a single named term
+  # from either form without disturbing the others; the grammar mirrors the base library
+  # `parse_filter_term`, but stays lenient (never raises) since it only pre-processes params.
+  module FilterParamsHelper
+
+    # The decoded value of `key`, from the direct param or the `:filter` string; nil when absent or
+    # blank. Filter-string values are JSON-encoded (`search="x"`), so quotes are stripped; a value
+    # that is not valid JSON falls back to its raw text.
+    def self.extract(filter_params, key)
+      key = key.to_s
+      direct = filter_params[key.to_sym]
+      return direct.to_s if direct.present?
+
+      filter_string = filter_params[:filter]
+      return nil if filter_string.blank?
+
+      term = filter_string.to_s.split('&').find { |t| term_field(t) == key }
+      return nil if term.nil?
+
+      parse_value(term.split('=', 2)[1].to_s.strip).to_s.presence
+    end
+
+    # `filter_params` with `key` removed from both the direct param and the `:filter` string (the
+    # `:filter` key is dropped entirely when no other term remains). Other terms are left verbatim.
+    def self.strip(filter_params, key)
+      key = key.to_s
+      result = filter_params.except(key.to_sym)
+      return result if result[:filter].blank?
+
+      remaining = result[:filter].to_s.split('&').reject { |t| term_field(t) == key }
+      remaining.empty? ? result.except(:filter) : result.merge(filter: remaining.join('&'))
+    end
+
+    # The field name of a `field=<json>` term.
+    def self.term_field(term)
+      term.to_s.split('=', 2).first.to_s.strip
+    end
+
+    # JSON-decodes a raw filter value, falling back to the raw string when it is not valid JSON.
+    def self.parse_value(raw)
+      JSON.parse(raw)
+    rescue JSON::ParserError, TypeError
+      raw
+    end
+  end
+end

data/lib/habarico/helpers/order_by_helper.rb

@@ -0,0 +1,56 @@
+module Habarico
+  # The one place that reads the `field:direction` notation, shared by the `order_by` query
+  # parameter and the `default_sorting` declarations.
+  #
+  # `Eluvia::PaginationHandler#set_pagination` reads the query parameter exactly this way and
+  # answers 422 for anything that does not match, so by the time habarico looks at the parameter
+  # every entry is known to be well formed. This helper has to stay in step with it.
+  module OrderByHelper
+
+    DIRECTIONS = %w[asc desc].freeze
+
+    # Splits a whole `order_by` value (`name:asc,created_at:desc`) into `[field_name, direction]`
+    # pairs, dropping every entry that is not in that form - `set_pagination` has already refused
+    # the request over those, so nothing downstream has to decide what to do with them.
+    def self.parse(value)
+      value.to_s.split(',').filter_map { |entry| parse_entry(entry) }
+    end
+
+    # Splits a single `field:direction` entry, or nil when it is not exactly one non-blank field
+    # name followed by one known direction.
+    def self.parse_entry(entry)
+      # `-1` keeps a trailing empty segment (`name:`), so it is read as a missing direction
+      # instead of a bare field name - the same way `set_pagination` reads it.
+      parts = segments(entry)
+      return nil unless parts.length == 2
+
+      field_name, direction = parts
+      return nil if field_name.blank? || !DIRECTIONS.include?(direction)
+
+      [field_name, direction]
+    end
+
+    # Field names of a whole value, tolerating an entry written without a direction the way a
+    # hand-written `default_sorting` may be - this reads declarations, not requests.
+    def self.field_names(value)
+      value.to_s.split(',').filter_map { |entry| field_name(entry) }
+    end
+
+    # Field name of a single entry, tolerating a bare `field` without a direction: a
+    # `default_sorting` declaration is written by hand and may be spelled that way.
+    def self.field_name(entry)
+      segments(entry).first.presence
+    end
+
+    # Direction of a single entry - `asc` unless `desc` is spelled out.
+    def self.direction(entry)
+      segments(entry)[1] == 'desc' ? 'desc' : 'asc'
+    end
+
+    def self.segments(entry)
+      entry.to_s.strip.split(':', -1)
+    end
+    private_class_method :segments
+
+  end
+end

data/lib/habarico/helpers/reflection_helper.rb

@@ -0,0 +1,61 @@
+module Habarico
+  module ReflectionHelper
+
+    # *************************************************************************
+    # Attributes model reflection methods
+    # *************************************************************************
+
+    def self.is_attributes_model_class?(model_class)
+      model_class.respond_to?(:ancestors) && model_class.ancestors.include?(Eluvia::ActiveModel::Attributes)
+    end
+
+    def self.is_attributes_model_instance?(model_instance)
+      model_instance.is_a?(Eluvia::ActiveModel::Attributes)
+    end
+
+    def self.is_has_one_reference?(model_class, field_name)
+      model_class.respond_to?(:has_reference?) && model_class.has_reference?(field_name, type: :has_one)
+    end
+
+    def self.is_has_many_reference?(model_class, field_name)
+      model_class.respond_to?(:has_reference?) && model_class.has_reference?(field_name, type: :has_many)
+    end
+
+    # *************************************************************************
+    # Active model reflection methods
+    # *************************************************************************
+
+    def self.is_active_model_class?(model_class)
+      model_class.respond_to?(:ancestors) && model_class.ancestors.include?(::ActiveModel::Model)
+    end
+
+    def self.is_active_model_instance?(model_instance)
+      model_instance.is_a?(::ActiveModel::Model)
+    end
+
+    # *************************************************************************
+    # Active record reflection methods
+    # *************************************************************************
+
+    def self.is_active_record_class?(model_class)
+      model_class.respond_to?(:ancestors) && model_class.ancestors.include?(::ActiveRecord::Base)
+    end
+
+    def self.is_active_record_instance?(model_instance)
+      model_instance.is_a?(::ActiveRecord::Base)
+    end
+
+    def self.is_belongs_to_association?(model_class, field_name)
+      is_active_record_class?(model_class) && model_class.reflect_on_association(field_name.to_sym)&.macro == :belongs_to
+    end
+
+    def self.is_has_one_association?(model_class, field_name)
+      is_active_record_class?(model_class) && model_class.reflect_on_association(field_name.to_sym)&.macro == :has_one
+    end
+
+    def self.is_has_many_association?(model_class, field_name)
+      is_active_record_class?(model_class) && model_class.reflect_on_association(field_name.to_sym)&.macro == :has_many
+    end
+
+  end
+end

data/lib/habarico/helpers/sorting_helper.rb

@@ -0,0 +1,136 @@
+module Habarico
+  # The one definition of what a resource offers for sorting.
+  #
+  # A field schema's `sort_by` is the value a client puts in `order_by` to sort by that field, so
+  # the schema generators and the `order_by` validator have to agree on it. They used to decide
+  # separately, and the validator's own rule - a declared field that is also a column - refused
+  # part of what the generators advertise: the lower bound of a range field, a column reached over
+  # an association, and a `sort_by` written on a `FieldReference` by hand.
+  module SortingHelper
+
+    # `sort_by` of a field of the resource schema (`FieldSchemaGenerator`): the field itself when a
+    # column or an attribute backs it, the lower bound when a range attribute does, and nothing
+    # when the field is not sortable on its own. `attr_name` is the attribute the field is backed
+    # by, which only differs from the field name where no range attribute can exist anyway.
+    def self.schema_sort_by(definition, model, field_name, attr_name: field_name)
+      if definition.sorting_fields.present?
+        return definition.sorting_fields.map(&:to_s).include?(field_name.to_s) ? field_name.to_s : nil
+      end
+
+      return nil unless Habarico::ReflectionHelper.is_active_record_class?(model)
+
+      # A standard DB column or a standard attribute of the model sorts under its own name.
+      Habarico::AttributesHelper.generate_attr_variants(model, field_name).each do |field_name_variant|
+        if model.columns_hash[field_name_variant.to_s] || model.attribute_names.include?(field_name_variant.to_s)
+          return field_name_variant.to_s
+        end
+      end
+
+      # A range attribute sorts by its lower bound, as long as that one is a DB column.
+      if model.respond_to?(:has_range_attr?) && model.has_range_attr?(attr_name)
+        lower_attr_name = model.find_range_attr(attr_name)[:lower_attr_name]
+        return lower_attr_name if model.columns_hash[lower_attr_name.to_s]
+      end
+
+      # Everything else is not sortable by default. To sort by a "belongs to" association, declare
+      # `sort_by` on the field descriptor.
+      nil
+    end
+
+    # `sort_by` of a field descriptor of a view (`FieldDescriptorGenerator`): a column of an
+    # association, addressed as `association__column` the way `order_2` expects it, or whatever the
+    # FieldReference declares for itself.
+    def self.descriptor_sort_by(model, field_reference)
+      name = field_reference.name.to_s
+      if Habarico::ReflectionHelper.is_active_record_class?(model) && name.include?('__')
+        split_name = name.split('__')
+        if split_name.size == 2
+          reflection = model.reflect_on_association(split_name[0].to_sym)
+          return name if reflection && reflection.klass.columns_hash[split_name[1]]
+        end
+      end
+
+      field_reference.sort_by
+    end
+
+    # Every value this resource accepts in `order_by`, or nil when it has no whitelist to offer -
+    # a model without ActiveRecord reflection exposes no columns to check a field name against, so
+    # the field names are left to the model itself.
+    def self.allowed_order_by_fields(definition)
+      # What the resource tells the frontend to sort by. The list view schema publishes a
+      # `default_sorting` - the resource's, or the view's own - and the frontend puts exactly that
+      # in `order_by` on the first request, so refusing it would refuse the backend's own answer.
+      declared = declared_sorting_fields(definition)
+
+      return (declared + definition.sorting_fields.map(&:to_s)).uniq if definition.sorting_fields.present?
+
+      model = definition.model
+      return nil unless Habarico::ReflectionHelper.is_active_record_class?(model)
+
+      names = declared
+
+      # What the resource schema advertises for each declared field.
+      (definition.fields + definition.read_only_fields).each do |field|
+        field_name = Habarico::AttributesHelper.field_name(field)
+        names << field.sort_by if field.is_a?(Habarico::FieldReference)
+        names << schema_sort_by(definition, model, field_name)
+      end
+
+      # What the resource's own list views add on top: a column of an association is declared
+      # there and never appears among the resource fields.
+      list_view_field_references(definition).each do |field_reference|
+        names << descriptor_sort_by(model, field_reference)
+      end
+
+      # Virtual sortable columns registered on the model with `order_attr`.
+      names += model.order_attrs.map { |order_attr| order_attr[:attr_name] } if model.respond_to?(:order_attrs)
+
+      names.compact.map { |name| normalize(name) }.uniq
+    end
+
+    # Field names of every ordering this resource advertises: the one the definition falls back to,
+    # the one each of its list views publishes on top of that, and the primary key.
+    def self.declared_sorting_fields(definition)
+      sortings = [definition.default_sorting]
+      sortings += definition.normalized_views.select { |view| view.type == :list }.map(&:default_sorting)
+
+      names = sortings.flat_map { |sorting| Habarico::OrderByHelper.field_names(sorting) }
+
+      # The primary key is advertised too, as `pk_field_name` on the resource schema: the frontend
+      # sorts by it whenever a list has no sorting of its own (`serializeOrderBy`). It is listed
+      # here rather than left to the tiebreaker, which a controller may point elsewhere.
+      names += Array(definition.model.try(:primary_key)).map(&:to_s)
+
+      names.uniq
+    end
+
+    # A `sort_by` as it arrives in `order_by`. The frontend rewrites the first `.` of the
+    # advertised value into `__` before sending it (`serializeOrderBy`), which is also the
+    # separator `order_2` splits an association off by.
+    def self.normalize(sort_by)
+      sort_by.to_s.sub('.', '__')
+    end
+
+    # FieldReferences declared in the resource's own list views, including the ones nested in
+    # boxes. A box pointing at another resource lists that resource's fields, not this one's.
+    def self.list_view_field_references(definition)
+      definition.normalized_views.select { |view| view.type == :list }.flat_map do |view|
+        field_references(view.boxes)
+      end
+    end
+    private_class_method :list_view_field_references
+
+    def self.field_references(boxes)
+      Array(boxes).flat_map do |item|
+        case item
+        when Habarico::Box then item.reference.present? ? [] : field_references(item.boxes)
+        when Habarico::FieldReference then [item]
+        when ::String, ::Symbol then [Habarico::FieldReference.new(name: item.to_s)]
+        else []
+        end
+      end
+    end
+    private_class_method :field_references
+
+  end
+end

data/lib/habarico/schema/action/action_schema.rb

@@ -0,0 +1,46 @@
+module Habarico
+  class ActionSchema
+    include ::ActiveModel::Model
+    include Eluvia::ActiveModel::Attributes
+    include Eluvia::ActiveModel::EnumAttribute
+    include Habarico::ExtensibleEnum
+
+    # Type of the action.
+    # `view` - opens a new view as redirect or dialog
+    # `link` - opens an external link
+    # `resource` - performs an action on the resource (like delete, update, etc.
+    string_attr :type
+    extensible_enum_attr :type, :ACTION_TYPE
+
+    # Flag indicating if the action uses primary key or not
+    boolean_attr :is_detail
+
+    # Human-readable label for the action (button)
+    string_attr :label
+
+    # Icon contained in the action button
+    string_attr :icon
+
+    # Color of the action button. Uses standard MUI color types
+    string_attr :color
+    enum_attr :color, Types::COLOR_TYPE
+
+    # Optional confirmation dialog before performing the action
+    has_one_attr :confirm_dialog, 'Habarico::ConfirmDialogProperties'
+
+    # Parameters specific to action type 'view'
+    has_one_attr :view, 'Habarico::ViewActionParameters'
+
+    # Parameters specific to action type 'resource'
+    has_one_attr :resource, 'Habarico::ResourceActionParameters'
+
+    # Parameters specific to action type 'link'
+    has_one_attr :link, 'Habarico::LinkActionParameters'
+
+    # Parameters specific to action type 'save'
+    has_one_attr :save, 'Habarico::SaveActionParameters'
+
+    # Parameters specific to action type 'upload-images'
+    has_one_attr :upload_images, 'Habarico::UploadImagesActionParameters'
+  end
+end

data/lib/habarico/schema/action/confirm_dialog_properties.rb

@@ -0,0 +1,13 @@
+module Habarico
+  class ConfirmDialogProperties
+    include ::ActiveModel::Model
+    include Eluvia::ActiveModel::Attributes
+
+    # Title of the confirm dialog
+    string_attr :title
+
+    # Message of the confirm dialog
+    string_attr :message
+
+  end
+end