typus-rails4 4.0.0.beta6

data/app/helpers/admin/resources/data_types/has_many_helper.rb

@@ -0,0 +1,76 @@
+module Admin::Resources::DataTypes::HasManyHelper
+
+  def has_many_filter(filter)
+    att_assoc = @resource.reflect_on_association(filter.to_sym)
+    class_name = att_assoc.options[:class_name] || filter.classify
+    resource = class_name.constantize
+
+    view_all = t('typus.filters.view_all', attribute: @resource.human_attribute_name(filter).downcase.pluralize)
+
+    items = [[view_all, '']]
+    items += resource.order(resource.typus_order_by).map { |v| [v.to_label, v.id] }
+  end
+
+  alias_method :has_and_belongs_to_many_filter, :has_many_filter
+
+  def typus_form_has_many(field)
+    setup_relationship(field)
+
+    options = { "resource[#{@reflection.foreign_key}]" => @item.id }
+
+    if @reflection.options && (as = @reflection.options[:as])
+      klass = @resource.is_sti? ? @resource.superclass : @resource
+      options.merge!("#{as}_type" => klass)
+    end
+
+    build_pagination
+    set_has_many_resource_actions
+
+    locals = {
+      association_name: @association_name,
+      add_new: build_add_new_for_has_many(@model_to_relate, field, options),
+      table: build_relationship_table,
+    }
+
+    render 'admin/templates/has_many', locals
+  end
+
+  def build_add_new_for_has_many(klass, field, options = {})
+    if admin_user.can?('create', klass)
+
+      html_options = set_modal_options_for(klass)
+      html_options['url'] = "/admin/#{klass.to_resource}/new?_popup=true"
+
+      link_to t('typus.buttons.add'), "##{html_options['data-controls-modal']}", html_options
+    end
+  end
+
+  def set_has_many_resource_actions
+    klass = @model_to_relate
+
+    @resource_actions = [
+      set_has_many_resource_edit_action(klass),
+      set_has_many_resource_show_action(klass),
+      set_has_many_resource_destroy_action(klass),
+    ]
+  end
+
+  def set_has_many_resource_edit_action(klass)
+    html_options = set_modal_options_for(klass)
+    html_options[:glyphicon] = 'edit'
+    [ 'typus.buttons.edit', { action: 'edit', anchor: html_options['data-controls-modal'] }, html_options ]
+  end
+
+  def set_has_many_resource_show_action(klass)
+    html_options = set_modal_options_for(klass)
+    html_options[:glyphicon] = 'info-sign'
+    [ 'typus.buttons.show', { action: 'show', anchor: html_options['data-controls-modal'] }, html_options ]
+  end
+
+  def set_has_many_resource_destroy_action(klass)
+    html_options = {}
+    html_options[:glyphicon] = 'remove'
+    [ 'typus.buttons.destroy', { action: 'destroy' }, html_options ]
+  end
+
+end

data/app/helpers/admin/resources/data_types/has_one_helper.rb

@@ -0,0 +1,44 @@
+module Admin::Resources::DataTypes::HasOneHelper
+
+  def typus_form_has_one(field)
+    setup_relationship(field)
+
+    related_items = @item.send(field)
+    @items =  related_items ? [related_items] : []
+
+    set_has_one_resource_actions
+
+    locals = {
+      association_name: @association_name,
+      table: build_relationship_table,
+      add_new: nil,
+    }
+
+    if @items.empty?
+      options = { "resource[#{@reflection.foreign_key}]" => @item.id }
+      locals[:add_new] = build_add_new_for_has_one(@model_to_relate, field, options)
+    end
+
+    render 'admin/templates/has_one', locals
+  end
+
+  def build_add_new_for_has_one(klass, field, options = {})
+    if admin_user.can?('create', klass)
+      default_options = {
+        controller: "/admin/#{klass.to_resource}",
+        action: 'new',
+        _popup: true,
+      }
+
+      link_to t('typus.buttons.add'), default_options.merge(options), { class: 'iframe_with_page_reload' }
+    end
+  end
+
+  def set_has_one_resource_actions
+    @resource_actions = [
+      ['typus.buttons.edit', { action: 'edit' }, {}],
+      ['typus.buttons.destroy', { action: 'destroy' }, { data: { confirm: t('typus.shared.confirm_question') } }],
+    ]
+  end
+
+end

data/app/helpers/admin/resources/data_types/integer_helper.rb

@@ -0,0 +1,13 @@
+module Admin::Resources::DataTypes::IntegerHelper
+
+  def integer_filter(filter)
+    values = set_context.send(filter.to_s.pluralize).to_a
+    attribute = @resource.human_attribute_name(filter)
+
+    items = [[attribute.titleize, '']]
+    array = values.first.is_a?(Array) ? values : values.map { |i| ["#{attribute}:#{i}", i] }
+
+    items + array
+  end
+
+end

data/app/helpers/admin/resources/data_types/paperclip_helper.rb

@@ -0,0 +1,49 @@
+module Admin::Resources::DataTypes::PaperclipHelper
+
+  def display_paperclip(item, attribute)
+    typus_paperclip_preview(item, attribute, 'paperclip_form_preview')
+  end
+
+  def table_paperclip_field(attribute, item)
+    typus_paperclip_preview(item, attribute)
+  end
+
+  def link_to_detach_attribute_for_paperclip(attribute)
+    validators = @item.class.validators.delete_if { |i| i.class != Paperclip::Validators::AttachmentPresenceValidator }.map(&:attributes).flatten.map(&:to_s)
+    attachment = @item.send(attribute)
+
+    if attachment.present? && !validators.include?(attribute) && attachment
+      attribute_i18n = @item.class.human_attribute_name(attribute)
+      link = link_to(
+        t('typus.buttons.remove'),
+        { action: 'update', id: @item.id, _nullify: attribute, _continue: true },
+        { data: { confirm: t('typus.shared.confirm_question') } }
+      )
+
+      label_text = <<-HTML
+#{attribute_i18n}
+<small>#{link}</small>
+      HTML
+      label_text.html_safe
+    end
+  end
+
+  def typus_paperclip_preview(item, attribute, partial = 'paperclip_preview')
+    data = item.send(attribute)
+    return unless data.exists?
+
+    styles = data.styles.keys
+    if data.content_type =~ /^image\/.+/ && styles.include?(Typus.file_preview) && styles.include?(Typus.file_thumbnail)
+      render "admin/templates/#{partial}",
+             attachment: data,
+             preview: data.url(Typus.file_preview),
+             table_thumb: data.url(Typus.file_thumbnail),
+             thumb: data.url(Typus.file_thumbnail),
+             item: item,
+             attribute: attribute
+    else
+      link_to data.original_filename, data.url(:original, false)
+    end
+  end
+
+end

data/app/helpers/admin/resources/data_types/selector_helper.rb

@@ -0,0 +1,11 @@
+module Admin::Resources::DataTypes::SelectorHelper
+
+  def table_selector_field(attribute, item)
+    item.mapping(attribute)
+  end
+
+  def display_selector(item, attribute)
+    item.mapping(attribute)
+  end
+
+end

data/app/helpers/admin/resources/data_types/string_helper.rb

@@ -0,0 +1,38 @@
+module Admin::Resources::DataTypes::StringHelper
+
+  def display_string(item, attribute)
+    if (data = item.send(attribute)).present?
+      data
+    else
+      mdash
+    end
+  end
+
+  alias_method :display_decimal, :display_string
+  alias_method :display_float, :display_string
+  alias_method :display_integer, :display_string
+  alias_method :display_position, :display_string
+  alias_method :display_text, :display_string
+  alias_method :display_virtual, :display_string
+
+  def string_filter(filter)
+    values = set_context.send(filter.to_s.pluralize).to_a
+    attribute = @resource.human_attribute_name(filter)
+
+    items = [[attribute.capitalize, '']]
+    array = values.first.is_a?(Array) ? values : values.map { |i| ["#{attribute}:#{i}", i] }
+
+    items + array
+  end
+
+  def table_string_field(attribute, item)
+    (raw_content = item.send(attribute)).present? ? raw_content : mdash
+  end
+
+  alias_method :table_decimal_field, :table_string_field
+  alias_method :table_float_field, :table_string_field
+  alias_method :table_integer_field, :table_string_field
+  alias_method :table_virtual_field, :table_string_field
+  alias_method :table_password_field, :table_string_field
+  alias_method :table_json_field, :table_string_field
+end

data/app/helpers/admin/resources/data_types/text_helper.rb

@@ -0,0 +1,6 @@
+module Admin::Resources::DataTypes::TextHelper
+
+  def table_text_field(attribute, item)
+    (raw_content = item.send(attribute)).present? ? truncate(raw_content) : mdash
+  end
+end

data/app/helpers/admin/resources/data_types/transversal_helper.rb

@@ -0,0 +1,8 @@
+module Admin::Resources::DataTypes::TransversalHelper
+
+  def table_transversal_field(attribute, item)
+    field_1, field_2 = attribute.split('.')
+    (related_item = item.send(field_1)) ? related_item.send(field_2) : mdash
+  end
+
+end

data/app/helpers/admin/resources/data_types/tree_helper.rb

@@ -0,0 +1,28 @@
+module Admin::Resources::DataTypes::TreeHelper
+
+  def table_tree_field(attribute, item)
+    item.parent ? item.parent.to_label : mdash
+  end
+
+  def typus_tree_field(attribute, form)
+    locals = {
+      attribute: attribute,
+      attribute_id: "#{@resource.table_name}_#{attribute}",
+      form: form,
+      label_text: @resource.human_attribute_name(attribute),
+      values: raw(expand_tree_into_select_field(@resource.roots, 'parent_id')),
+    }
+
+    render 'admin/templates/tree', locals
+  end
+
+  def expand_tree_into_select_field(items, attribute)
+    String.new.tap do |html|
+      items.each do |item|
+        html << %{<option #{'selected' if @item.send(attribute) == item.id} value="#{item.id}">#{'&nbsp;' * item.ancestors.size * 2} #{item.to_label}</option>\n}
+        html << expand_tree_into_select_field(item.children, attribute) unless item.children.empty?
+      end
+    end
+  end
+
+end

data/app/helpers/admin/resources/display_helper.rb

@@ -0,0 +1,27 @@
+module Admin::Resources::DisplayHelper
+
+  def mdash
+    '—'.html_safe
+  end
+
+  def build_display(item, fields)
+    fields.map do |attribute, type|
+      condition = (type == :boolean) || item.respond_to?(attribute)
+      next unless condition
+      [@resource.human_attribute_name(attribute), send("display_#{type}", item, attribute)]
+    end.compact
+  end
+
+  def typus_relationships
+    String.new.tap do |html|
+      @resource.typus_defaults_for(:relationships).each do |relationship|
+        association = @resource.reflect_on_association(relationship.to_sym)
+        macro, klass = association.macro, association.class_name.constantize
+        if [:has_many, :has_one].include?(macro) && admin_user.can?('read', klass)
+          html << send("typus_form_#{macro}", relationship)
+        end
+      end
+    end.html_safe
+  end
+
+end

data/app/helpers/admin/resources/filters_helper.rb

@@ -0,0 +1,18 @@
+module Admin::Resources::FiltersHelper
+
+  def build_filters(resource = @resource, params = self.params)
+    if (typus_filters = resource.typus_filters).any?
+      locals = {}
+
+      locals[:filters] = typus_filters.map do |key, value|
+                           { key: key, value: send("#{value}_filter", key) }
+                         end
+
+      rejections = %w(controller action locale utf8 sort_order order_by subdomain) + locals[:filters].map { |f| f[:key] }
+      locals[:hidden_filters] = params.dup.delete_if { |k, _| rejections.include?(k) }
+
+      render 'helpers/admin/resources/filters', locals
+    end
+  end
+
+end

data/app/helpers/admin/resources/form_helper.rb

@@ -0,0 +1,85 @@
+module Admin::Resources::FormHelper
+
+  def build_form(fields, form)
+    String.new.tap do |html|
+      fields.each do |key, value|
+        value = :template if (template = @resource.typus_template(key))
+        html << case value
+                when :belongs_to
+                  typus_belongs_to_field(key, form)
+                when :tree
+                  typus_tree_field(key, form)
+                when :boolean, :date, :datetime, :text, :time, :password, :selector, :dragonfly, :paperclip, :json
+                  typus_template_field(key, value, form)
+                when :template
+                  typus_template_field(key, template, form)
+                when :has_and_belongs_to_many
+                  typus_has_and_belongs_to_many_field(key, form)
+                else
+                  typus_template_field(key, :string, form)
+                end
+      end
+    end.html_safe
+  end
+
+  def typus_template_field(attribute, template, form)
+    options = {
+      start_year: @resource.typus_options_for(:start_year),
+      end_year: @resource.typus_options_for(:end_year),
+      minute_step: @resource.typus_options_for(:minute_step),
+      include_blank: true,
+      class: 'form-control',
+    }
+
+    label_text = @resource.human_attribute_name(attribute)
+
+    locals = {
+      resource: @resource,
+      attribute: attribute,
+      attribute_id: "#{@resource.table_name}_#{attribute}",
+      options: options,
+      html_options: {},
+      form: form,
+      label_text: label_text,
+      help_block: help_block,
+    }
+
+    render "admin/templates/#{template}", locals
+  end
+
+  # Placeholder
+  def help_block
+    false
+  end
+
+  def build_save_options
+    save_options_for_user_class || save_options_for_headless_mode || save_options
+  end
+
+  def save_options
+    options = {}
+
+    if admin_user.can?('create', @resource.model_name)
+      options[:_addanother] = 'typus.buttons.save_addanother'
+    end
+
+    if admin_user.can?('edit', @resource.model_name)
+      options[:_continue] = 'typus.buttons.save_continue'
+    end
+
+    options[:_save] = 'typus.buttons.save'
+
+    options
+  end
+
+  def save_options_for_headless_mode
+    return unless headless_mode?
+    { _continue: 'typus.buttons.save' }
+  end
+
+  def save_options_for_user_class
+    return unless defined?(Typus.user_class) && Typus.user_class == @resource && admin_user.is_not_root?
+    { _continue: 'typus.buttons.save_continue' }
+  end
+
+end

data/app/helpers/admin/resources/list_helper.rb

@@ -0,0 +1,31 @@
+module Admin::Resources::ListHelper
+
+  def list_actions
+    resources_actions_for_current_role.map do |body, url, options|
+      path = params.dup.merge!(url).compact.cleanup
+      link_to t(body), path, options
+    end.compact.reverse.join(' / ').html_safe
+  end
+
+  def resources_actions_for_current_role
+    resources_actions.reject do |_, url, _|
+      admin_user.cannot?(url[:action], @resource.name)
+    end
+  end
+
+  def build_actions(&block)
+    render 'helpers/admin/resources/actions', block: block
+  end
+
+  #--
+  # If partial `list` exists we will use it. This partial will have available
+  # the `@items` so we can do whatever we want there. Notice that pagination
+  # is still available.
+  #++
+  def build_list(model, fields, items, resource = @resource.to_resource, link_options = {}, association = nil, association_name = nil)
+    render "admin/#{resource}/list", items: items
+  rescue ActionView::MissingTemplate
+    build_table(model, fields, items, link_options, association, association_name)
+  end
+
+end