Module: Alchemy::ResourcesHelper

Included in:
Admin::ResourcesController
Defined in:
lib/alchemy/resources_helper.rb

Instance Method Summary collapse

Instance Method Details

#contains_relations?Boolean

Returns true if the resource contains any relations

Returns:

  • (Boolean)

126
127
128
# File 'lib/alchemy/resources_helper.rb', line 126

def contains_relations?
  resource_handler.resource_relations.present?
end

#edit_resource_path(resource = nil, options = {}) ⇒ Object


48
49
50
51
# File 'lib/alchemy/resources_helper.rb', line 48

def edit_resource_path(resource = nil, options = {})
  path_segments = (resource_scope + [resource] || resource_handler.resource_array)
  edit_polymorphic_path path_segments, options
end

#new_resource_path(options = {}) ⇒ Object


44
45
46
# File 'lib/alchemy/resources_helper.rb', line 44

def new_resource_path(options = {})
  new_polymorphic_path (resource_scope + [resource_handler.namespaced_resource_name]), options
end

#render_attribute(resource, attribute, options = {}) ⇒ String

Returns the value from resource attribute

If the attribute has a relation, the related object's attribute value will be returned.

The output will be truncated after 50 chars. Pass another number to truncate then and pass false to disable this completely.

Parameters:

  • resource (Alchemy::Resource)
  • attribute (Hash)
  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :truncate (Hash) — default: 50

    The length of the value returned.

  • :datetime_format (Hash) — default: alchemy.default

    The format of timestamps.

  • :time_format (Hash) — default: alchemy.time

    The format of time values.

Returns:

  • (String)

76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
# File 'lib/alchemy/resources_helper.rb', line 76

def render_attribute(resource, attribute, options = {})
  attribute_value = resource.send(attribute[:name])
  if attribute[:relation]
    record = resource.send(attribute[:relation][:name])
    value = record.present? ? record.send(attribute[:relation][:attr_method]) : Alchemy.t(:not_found)
  elsif attribute_value && attribute[:type].to_s =~ /(date|time)/
    localization_format = if attribute[:type] == :datetime
      options[:datetime_format] || :'alchemy.default'
    elsif attribute[:type] == :date
      options[:date_format] || :'alchemy.default'
    else
      options[:time_format] || :'alchemy.time'
    end
    value = l(attribute_value, format: localization_format)
  else
    value = attribute_value
  end

  options.reverse_merge!(truncate: 50)
  if options[:truncate]
    value.to_s.truncate(options.fetch(:truncate, 50))
  else
    value
  end
end

#render_resourcesObject

Renders the row for a resource record in the resources table.

This helper has a nice fallback. If you create a partial for your record then this partial will be rendered.

Otherwise the default app/views/alchemy/admin/resources/_resource.html.erb partial gets rendered.

Example

For a resource named Comment you can create a partial named _comment.html.erb

# app/views/admin/comments/_comment.html.erb
<tr>
  <td><%= comment.title %></td>
  <td><%= comment.body %></td>
</tr>

NOTE: Alchemy gives you a local variable named like your resource


165
166
167
168
169
# File 'lib/alchemy/resources_helper.rb', line 165

def render_resources
  render partial: resource_name, collection: resources_instance_variable
rescue ActionView::MissingTemplate
  render partial: "resource", collection: resources_instance_variable
end

#resource_attribute_field_options(attribute) ⇒ Object

Returns a options hash for simple_form input fields.


103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
# File 'lib/alchemy/resources_helper.rb', line 103

def resource_attribute_field_options(attribute)
  options = {hint: resource_handler.help_text_for(attribute)}
  input_type = attribute[:type].to_s
  case input_type
  when "boolean"
    options
  when "date", "time", "datetime"
    date = resource_instance_variable.send(attribute[:name]) || Time.current
    options.merge(
      as: "string",
      input_html: {
        "data-datepicker-type" => input_type,
        value: date ? date.iso8601 : nil,
      },
    )
  when "text"
    options.merge(as: "text", input_html: {rows: 4})
  else
    options.merge(as: "string")
  end
end

#resource_filter_selectObject


179
180
181
182
183
184
185
186
# File 'lib/alchemy/resources_helper.rb', line 179

def resource_filter_select
  resource_model.alchemy_resource_filters.map do |filter_scope|
    [
      Alchemy.t(filter_scope.to_sym, scope: ["resources", resource_name, "filters"]),
      filter_scope,
    ]
  end
end

#resource_has_filtersObject


175
176
177
# File 'lib/alchemy/resources_helper.rb', line 175

def resource_has_filters
  resource_model.respond_to?(:alchemy_resource_filters)
end

#resource_has_tagsObject


171
172
173
# File 'lib/alchemy/resources_helper.rb', line 171

def resource_has_tags
  resource_model.respond_to?(:tag_counts) && resource_model.tag_counts.any?
end

#resource_instance_variableObject


16
17
18
# File 'lib/alchemy/resources_helper.rb', line 16

def resource_instance_variable
  instance_variable_get("@#{resource_handler.resource_name}")
end

#resource_modelObject


57
58
59
# File 'lib/alchemy/resources_helper.rb', line 57

def resource_model
  resource_handler.model
end

#resource_nameObject


53
54
55
# File 'lib/alchemy/resources_helper.rb', line 53

def resource_name
  resource_handler.resource_name
end

#resource_path(resource = resource_handler.namespaced_resource_name, options = {}) ⇒ Object


40
41
42
# File 'lib/alchemy/resources_helper.rb', line 40

def resource_path(resource = resource_handler.namespaced_resource_name, options = {})
  resources_path(resource, options)
end

#resource_relations_namesObject

Returns an array of all resource_relations names


131
132
133
# File 'lib/alchemy/resources_helper.rb', line 131

def resource_relations_names
  resource_handler.resource_relations.collect { |_k, v| v[:name].to_sym }
end

#resource_scopeObject


32
33
34
# File 'lib/alchemy/resources_helper.rb', line 32

def resource_scope
  @_resource_scope ||= [resource_url_proxy].concat(resource_handler.namespace_for_scope)
end

#resource_url_proxyObject


24
25
26
27
28
29
30
# File 'lib/alchemy/resources_helper.rb', line 24

def resource_url_proxy
  if resource_handler.in_engine?
    eval(resource_handler.engine_name)
  else
    main_app
  end
end

#resource_window_sizeObject

Alchemy::ResourceHelper

Used to DRY up resource like structures in Alchemy's admin backend in combination with Alchemy::Resource

See Alchemy::Resource for examples how to initialize a resource_handler


12
13
14
# File 'lib/alchemy/resources_helper.rb', line 12

def resource_window_size
  @resource_window_size ||= "420x#{100 + resource_handler.attributes.length * 40}"
end

#resources_instance_variableObject


20
21
22
# File 'lib/alchemy/resources_helper.rb', line 20

def resources_instance_variable
  instance_variable_get("@#{resource_handler.resources_name}")
end

#resources_path(resource_or_name = resource_handler.namespaced_resources_name, options = {}) ⇒ Object


36
37
38
# File 'lib/alchemy/resources_helper.rb', line 36

def resources_path(resource_or_name = resource_handler.namespaced_resources_name, options = {})
  polymorphic_path (resource_scope + [resource_or_name]), options
end

#sortable_resource_header_column(attribute) ⇒ Object

Returns the attribute's column for sorting

If the attribute contains a resource_relation, then the table and column for related model will be returned.


139
140
141
142
143
144
145
# File 'lib/alchemy/resources_helper.rb', line 139

def sortable_resource_header_column(attribute)
  if relation = attribute[:relation]
    "#{relation[:model_association].name}_#{relation[:attr_method]}"
  else
    attribute[:name]
  end
end