|
module FormHelper
|
|
def text_f(f, attr, options = {})
|
|
field(f, attr, options) do
|
|
addClass options, "form-control"
|
|
options[:focus_on_load] = true if options[:focus_on_load].nil? && attr.to_s == 'name'
|
|
f.text_field attr, options
|
|
end
|
|
end
|
|
|
|
def textarea_f(f, attr, options = {})
|
|
field(f, attr, options) do
|
|
options[:rows] = line_count(f, attr) if options[:rows] == :auto
|
|
addClass options, "form-control"
|
|
f.text_area(attr, options)
|
|
end
|
|
end
|
|
|
|
def password_f(f, attr, options = {})
|
|
unset_button = options.delete(:unset)
|
|
value = f.object[attr] if options.delete(:keep_value)
|
|
password_field_tag(:fakepassword, value, :style => 'display: none', :autocomplete => 'new-password-fake') +
|
|
field(f, attr, options) do
|
|
options[:autocomplete] ||= 'new-password'
|
|
options[:placeholder] ||= password_placeholder(f.object, attr)
|
|
options[:disabled] = true if unset_button
|
|
options[:value] = value if value.present?
|
|
addClass options, 'form-control'
|
|
pass = f.password_field(attr, options) +
|
|
'<span class="glyphicon glyphicon-warning-sign input-addon"
|
|
title="'.html_safe + _('Caps lock ON') +
|
|
'" style="display:none"></span>'.html_safe
|
|
if unset_button
|
|
button = link_to_function(icon_text("edit", "", :kind => "pficon"), 'toggle_input_group(this)', {:id => 'disable-pass-btn', :class => 'btn btn-default', :title => _("Change the password")})
|
|
input_group(pass, input_group_btn(button))
|
|
else
|
|
pass
|
|
end
|
|
end
|
|
end
|
|
|
|
def checkbox_f(f, attr, options = {}, checked_value = "1", unchecked_value = "0")
|
|
text = options.delete(:help_text)
|
|
inline = options.delete(:help_inline)
|
|
field(f, attr, options) do
|
|
help_inline = inline.blank? ? '' : content_tag(:span, inline, :class => "help-inline")
|
|
f.check_box(attr, options, checked_value, unchecked_value) + " #{text} " + help_inline.html_safe
|
|
end
|
|
end
|
|
|
|
def multiple_checkboxes(f, attr, klass, associations, options = {}, html_options = {})
|
|
association_name = attr || ActiveModel::Naming.plural(associations)
|
|
associated_obj = klass.send(association_name)
|
|
selected_ids = options.delete(:selected_ids) || associated_obj.map(&:id)
|
|
multiple_selects(f, attr, associations, selected_ids, options, html_options)
|
|
end
|
|
|
|
# add hidden field for options[:disabled]
|
|
def multiple_selects(f, attr, associations, selected_ids, options = {}, html_options = {})
|
|
options[:size] = "col-md-10"
|
|
case attr
|
|
when :organizations
|
|
klass = Organization
|
|
when :locations
|
|
klass = Location
|
|
else
|
|
klass = nil
|
|
end
|
|
authorized = AssociationAuthorizer.authorized_associations(associations.reorder(nil), klass).all
|
|
|
|
# select2.js breaks the multiselects disabled items location
|
|
# http://projects.theforeman.org/issues/12028
|
|
html_options["class"] ||= ""
|
|
html_options["class"] += " without_select2"
|
|
html_options["class"].strip!
|
|
|
|
unauthorized = selected_ids.blank? ? [] : selected_ids - authorized.map(&:id)
|
|
field(f, attr, options) do
|
|
attr_ids = attr.to_s
|
|
attr_ids = (attr_ids.singularize + '_ids').to_sym unless attr_ids.end_with?('_ids')
|
|
hidden_fields = ''
|
|
html_options["data-useds"] ||= "[]"
|
|
JSON.parse(html_options["data-useds"]).each do |disabled_value|
|
|
hidden_fields += f.hidden_field(attr_ids, :multiple => true, :value => disabled_value, :id => '')
|
|
end
|
|
unauthorized.each do |unauthorized_value|
|
|
hidden_fields += f.hidden_field(attr_ids, :multiple => true, :value => unauthorized_value, :id => '')
|
|
end
|
|
hidden_fields + f.collection_select(attr_ids, authorized.sort_by { |a| a.to_s },
|
|
:id, options.delete(:object_label_method) || :to_label, options.merge(:selected => selected_ids),
|
|
html_options.merge(:multiple => true))
|
|
end
|
|
end
|
|
|
|
def line_count(f, attr)
|
|
rows = f.object.try(attr).to_s.lines.count rescue 1
|
|
(rows == 0) ? 1 : rows
|
|
end
|
|
|
|
def radio_button_f(f, attr, options = {})
|
|
text = options.delete(:text)
|
|
value = options.delete(:value)
|
|
label_tag('', :class => "radio-inline") do
|
|
f.radio_button(attr, value, options) + " #{text} "
|
|
end
|
|
end
|
|
|
|
def select_f(f, attr, array, id, method, select_options = {}, html_options = {})
|
|
array = array.to_a.dup
|
|
disable_button = select_options.delete(:disable_button)
|
|
include_blank = select_options.delete(:include_blank)
|
|
disable_button_enabled = select_options.delete(:disable_button_enabled)
|
|
user_set = !!select_options.delete(:user_set)
|
|
|
|
if include_blank
|
|
blank_value = include_blank.is_a?(TrueClass) ? nil : include_blank
|
|
blank_option = OpenStruct.new({id => '', method => blank_value })
|
|
# if the method is to_s, OpenStruct will respond with its own version.
|
|
# in this case, I need to undefine its own alias to to_s, and use the attribute
|
|
# that was defined in the struct.
|
|
blank_option.instance_eval('undef to_s', __FILE__, __LINE__) if method.to_s == 'to_s' || id.to_s == 'to_s'
|
|
array.insert(0, blank_option)
|
|
end
|
|
|
|
select_options[:disabled] = '' if select_options[:disabled] == include_blank
|
|
html_options[:disabled] = true if disable_button_enabled
|
|
|
|
html_options[:size] = 'col-md-10' if html_options[:multiple]
|
|
field(f, attr, html_options) do
|
|
addClass html_options, "form-control"
|
|
|
|
collection_select = f.collection_select(attr, array, id, method, select_options, html_options)
|
|
|
|
if disable_button
|
|
button_part =
|
|
content_tag :span, class: 'input-group-btn' do
|
|
content_tag(:button, disable_button, :type => 'button', :href => '#',
|
|
:name => 'is_overridden_btn',
|
|
:onclick => "disableButtonToggle(this)",
|
|
:class => 'btn btn-default btn-can-disable' + (disable_button_enabled ? ' active' : ''),
|
|
:data => { :toggle => 'button', :explicit => user_set })
|
|
end
|
|
|
|
input_group collection_select, button_part
|
|
else
|
|
collection_select
|
|
end
|
|
end
|
|
end
|
|
|
|
def addClass(options = {}, new_class = '')
|
|
options[:class] = "#{new_class} #{options[:class]}"
|
|
end
|
|
|
|
def input_group(*controls)
|
|
content_tag :div, class: 'input-group' do
|
|
controls.map { |control_html| concat(control_html) }
|
|
end
|
|
end
|
|
|
|
def input_group_btn(*controls)
|
|
content_tag :span, class: 'input-group-btn' do
|
|
controls.join(' ').html_safe
|
|
end
|
|
end
|
|
|
|
def time_zone_select_f(f, attr, default_timezone, select_options = {}, html_options = {})
|
|
field(f, attr, html_options) do
|
|
addClass html_options, "form-control"
|
|
f.time_zone_select(attr, [default_timezone], select_options, html_options)
|
|
end
|
|
end
|
|
|
|
def selectable_f(f, attr, array, select_options = {}, html_options = {})
|
|
html_options[:size] = 'col-md-10' if html_options[:multiple]
|
|
field(f, attr, html_options) do
|
|
form_select_f(f, attr, array, select_options, html_options)
|
|
end
|
|
end
|
|
|
|
def selectable_f_inline(f, attr, array, select_options = {}, html_options = {})
|
|
html_options[:size] = 'col-md-10' if html_options[:multiple]
|
|
form_select_f(f, attr, array, select_options, html_options)
|
|
end
|
|
|
|
def spinner_button_f(f, caption, action, html_options = {})
|
|
html_options[:class] ||= 'btn-default'
|
|
html_options[:class] = "btn btn-spinner #{html_options[:class]}"
|
|
caption = '<div class="caption">' + caption + '</div>'
|
|
caption += hidden_spinner('', :id => html_options[:spinner_id], :class => html_options[:spinner_class])
|
|
link_to_function(caption.html_safe, action, html_options)
|
|
end
|
|
|
|
def file_field_f(f, attr, options = {})
|
|
if options[:file_name]
|
|
html = content_tag(:b) { options.delete(:file_name) }
|
|
html += content_tag(:hr)
|
|
html += content_tag(:div, :style => "margin-bottom: 10px") { _("Choose a new file:") }
|
|
end
|
|
field(f, attr, options) do
|
|
(html || " ") + (f.file_field attr, options)
|
|
end
|
|
end
|
|
|
|
# Returns an AutoComplete React input tailored for accessing a specified attribute (identified by +attr+) on an object
|
|
# assigned to the form (identified by +f+). Additional properties on the input tag can be passed as a
|
|
# hash with +options+. These options will be tagged onto the React Component as an props as in the example
|
|
# shown.
|
|
#
|
|
# ==== Options
|
|
# * Creates standard React props for the component.
|
|
# * <tt>:url</tt> - path where the search results should be fetched from.
|
|
# * <tt>:disabled</tt> - If set to true, the user will not be able to use this input.
|
|
# * <tt>:search_query</tt> - Default search query.
|
|
#
|
|
# ==== Examples
|
|
# form_for(@user) do |f|
|
|
# autocomplete_f(f, :country, url: api_countries_path, search_query: 'Czech')
|
|
# end
|
|
# # => <AutoComplete id="user_country" name="user[country]" url="/api/countries/auto_complete_country" searchQuery="Czech" />
|
|
def autocomplete_f(f, attr, options = {})
|
|
options[:data] = {
|
|
autocomplete: {
|
|
searchQuery: options[:search_query] || f.object&.search || '',
|
|
url: options[:full_path] || (options[:path] || send("#{auto_complete_controller_name}_path")) + "/auto_complete_#{attr}",
|
|
},
|
|
controller: options[:path] || auto_complete_controller_name,
|
|
disabled: options[:disabled] || false,
|
|
}
|
|
options[:onSearch] = nil
|
|
react_form_input('autocomplete', f, attr, options)
|
|
end
|
|
|
|
def byte_size_f(f, attr, options = {})
|
|
react_form_input('memory', f, attr, options)
|
|
end
|
|
|
|
def counter_f(f, attr, options = {})
|
|
react_form_input('counter', f, attr, options)
|
|
end
|
|
|
|
def submit_or_cancel(f, overwrite = false, args = { })
|
|
args[:cancel_path] ||= resource_path(controller_name)
|
|
cancel_btn = args[:react_cancel_button] ? react_cancel_button(args) : link_to(_("Cancel"), args[:cancel_path], :class => "btn btn-default")
|
|
content_tag(:div, :class => "clearfix") do
|
|
content_tag(:div, :class => "form-actions") do
|
|
text = overwrite ? _("Overwrite") : args.delete(:button_text) || _("Submit")
|
|
options = options_for_submit_or_cancel(f, overwrite, args)
|
|
f.submit(text, options) + " " + cancel_btn
|
|
end
|
|
end
|
|
end
|
|
|
|
def react_cancel_button(args)
|
|
react_component('RedirectCancelButton', { :cancelPath => args[:cancel_path] })
|
|
end
|
|
|
|
def options_for_submit_or_cancel(f, overwrite, args)
|
|
options = {}
|
|
options[:disabled] = true if args[:disabled]
|
|
options[:class] = "btn btn-#{overwrite ? 'danger' : 'primary'} remove_form_templates"
|
|
options[:data] = args[:data] if args.key?(:data)
|
|
options
|
|
end
|
|
|
|
def add_help_to_label(size_class, label, help_inline)
|
|
label.html_safe +
|
|
content_tag(:div, :class => size_class) do
|
|
yield
|
|
end.html_safe + help_inline.html_safe
|
|
end
|
|
|
|
def is_required?(f, attr)
|
|
return false unless f && f.object.class.respond_to?(:validators_on)
|
|
f.object.class.validators_on(attr).any? do |validator|
|
|
options = validator.options.keys.map(&:to_s)
|
|
validator.is_a?(ActiveModel::Validations::PresenceValidator) && !options.include?('if') && !options.include?('unless')
|
|
end
|
|
end
|
|
|
|
def form_for(record_or_name_or_array, *args, &proc)
|
|
if args.last.is_a?(Hash)
|
|
args.last[:html] = {:class => "form-horizontal well"}.merge(args.last[:html] || {})
|
|
else
|
|
args << {:html => {:class => "form-horizontal well"}}
|
|
end
|
|
super record_or_name_or_array, *args, &proc
|
|
end
|
|
|
|
def number_f(f, attr, options = {})
|
|
field(f, attr, options) do
|
|
addClass options, "form-control"
|
|
f.number_field attr, options
|
|
end
|
|
end
|
|
|
|
def help_inline(inline, error)
|
|
help_inline = error.empty? ? inline : content_tag(:span, error.to_sentence, :class => 'error-message')
|
|
case help_inline
|
|
when blank?
|
|
""
|
|
when :indicator
|
|
content_tag(:span, content_tag(:div, '', :class => 'hide spinner spinner-xs'),
|
|
:class => 'help-block').html_safe
|
|
else
|
|
content_tag(:span, help_inline, :class => "help-block help-inline")
|
|
end
|
|
end
|
|
|
|
def add_label(options, f, attr)
|
|
return ''.html_safe if options[:label] == :none
|
|
|
|
label_size = options.delete(:label_size) || "col-md-2"
|
|
required_mark = check_required(options, f, attr)
|
|
label = ''.html_safe + options.delete(:label)
|
|
label = get_attr_label(f, attr).to_s.html_safe if label.empty?
|
|
|
|
if options[:label_help].present?
|
|
label += ' '.html_safe + popover("", options[:label_help], options[:label_help_options] || {})
|
|
end
|
|
label = label.present? ? label_tag(attr, label.to_s + required_mark.to_s, :class => label_size + " control-label") : ''
|
|
label
|
|
end
|
|
|
|
def check_required(options, f, attr)
|
|
required = options.delete(:required) # we don't want to use html5 required attr so we delete the option
|
|
return ' *'.html_safe if required.nil? ? is_required?(f, attr) : required
|
|
end
|
|
|
|
def blank_or_inherit_f(f, attr, blank_value: _("no value"))
|
|
return true unless f.object.respond_to?(:parent_id) && f.object.parent_id
|
|
inherited_value = f.object.send(attr)
|
|
inherited_value = inherited_value.name_method if inherited_value.present? && inherited_value.respond_to?(:name_method)
|
|
inherited_value ||= blank_value
|
|
_("Inherit parent (%s)") % inherited_value
|
|
end
|
|
|
|
def link_to_remove_fields(name, f, options = {})
|
|
options[:title] ||= _("Remove Parameter")
|
|
method_name = f.object.respond_to?(:_destroy) ? :_destroy : :_delete
|
|
f.hidden_field(method_name) + link_to_function(icon_text('remove', name, :kind => 'pficon'), "remove_fields(this)", options)
|
|
end
|
|
|
|
# Creates a link to a javascript function that creates field entries for the association on the web page
|
|
# +name+ : String containing links's text
|
|
# +f+ : FormBuiler object
|
|
# +association : The field are created to allow entry into this association
|
|
# +partial+ : String containing an optional partial into which we render
|
|
def link_to_add_fields(name, f, association, partial = nil, options = {})
|
|
new_object = options.delete(:object) || f.object.class.reflect_on_association(association).klass.new
|
|
locals_option = options.delete(:locals) || {}
|
|
fields = f.fields_for(association, new_object, :child_index => "new_#{association}") do |builder|
|
|
render((partial.nil? ? association.to_s.singularize + "_fields" : partial),
|
|
{ :f => builder }.merge(locals_option))
|
|
end
|
|
options[:class] = link_to_add_fields_classes(options)
|
|
link_to_function(name, "add_fields('#{options[:target]}', '#{association}', '#{escape_javascript(fields)}', '#{options[:direction] || 'append'}')".html_safe, options)
|
|
end
|
|
|
|
def field(f, attr, options = {})
|
|
table_field = options.delete(:table_field)
|
|
error = options.delete(:error) || get_attr_error(f, attr)
|
|
help_inline = help_inline(options.delete(:help_inline), error)
|
|
help_inline += options[:help_inline_permanent] unless options[:help_inline_permanent].nil?
|
|
size_class = options.delete(:size) || "col-md-4"
|
|
wrapper_class = options.delete(:wrapper_class) || "form-group"
|
|
|
|
label = options[:no_label] ? "" : add_label(options, f, attr)
|
|
|
|
if table_field
|
|
add_help_to_label(size_class, label, help_inline) do
|
|
yield
|
|
end.html_safe
|
|
else
|
|
help_block = content_tag(:span, options.delete(:help_block), :class => "help-block")
|
|
|
|
content_tag(:div, :class => "clearfix") do
|
|
content_tag(:div, :class => "#{wrapper_class} #{error.empty? ? '' : 'has-error'}",
|
|
:id => options.delete(:control_group_id)) do
|
|
input = capture do
|
|
if (group_btn = options.delete(:input_group_btn))
|
|
input_group(yield.html_safe, input_group_btn(group_btn))
|
|
else
|
|
yield.html_safe
|
|
end
|
|
end
|
|
add_help_to_label(size_class, label, help_inline) do
|
|
input + help_block.html_safe
|
|
end
|
|
end.html_safe
|
|
end
|
|
end
|
|
end
|
|
|
|
def date_local_f(f, attr, options = {})
|
|
react_form_input('date', f, attr, options)
|
|
end
|
|
|
|
def datetime_local_f(f, attr, options = {})
|
|
react_form_input('dateTime', f, attr, options)
|
|
end
|
|
|
|
def orderable_select_f(f, attr, choices, select_options = {}, html_options = {})
|
|
options = choices.collect { |choice| { label: choice[0], value: choice[1] } } if choices.is_a?(Array)
|
|
options = choices.collect { |(key, val)| { label: val, value: key } } if choices.is_a?(Hash)
|
|
input_props = select_options.merge(options: options)
|
|
react_form_input('orderableSelect', f, attr, html_options.merge(input_props: input_props))
|
|
end
|
|
|
|
def react_form_input(type, f, attr, options = {})
|
|
options[:label] ||= get_attr_label(f, attr)
|
|
options[:error] ||= get_attr_error(f, attr)
|
|
options[:error] = options[:error]&.to_sentence
|
|
options[:required] = is_required?(f, attr) unless options.key?(:required)
|
|
|
|
Tags::ReactInput.new(f.object_name, attr, self, options.merge(type: type, object: f.object)).render
|
|
end
|
|
|
|
def advanced_switch_f(default_text, switch_text)
|
|
content_tag :div, :class => 'form-group' do
|
|
content_tag(:div, '', :class => 'col-md-2 control-label') +
|
|
content_tag(:div, :class => 'col-md-4') do
|
|
content_tag(:i, '', :class => 'fa fa-angle-right') + ' ' +
|
|
link_to(default_text, '#', :class => 'advanced_fields_switch', :'data-alternative-label' => switch_text)
|
|
end
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def get_attr_label(f, attr)
|
|
if f.try(:object) && (clazz = f.object.class).respond_to?(:gettext_translation_for_attribute_name)
|
|
s_(clazz.gettext_translation_for_attribute_name(attr)).titleize
|
|
end
|
|
end
|
|
|
|
def get_attr_error(f, attr)
|
|
f.object.errors[attr] if f&.object.respond_to?(:errors)
|
|
end
|
|
|
|
def form_select_f(f, attr, array, select_options = {}, html_options = {})
|
|
addClass html_options, "form-control"
|
|
f.select attr, array, select_options, html_options
|
|
end
|
|
|
|
def link_to_add_fields_classes(options = {})
|
|
classes = "btn btn-default #{options[:class]}"
|
|
classes << ' btn-primary' if options.fetch(:primary_button, true)
|
|
classes
|
|
end
|
|
end
|
