Module: Effective::Resources::Forms

Included in:
Effective::Resource
Defined in:
app/models/effective/resources/forms.rb

Instance Method Summary collapse

Instance Method Details

#search_form_field(name, type = nil) ⇒ Object

Used by datatables



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'app/models/effective/resources/forms.rb', line 8

def search_form_field(name, type = nil)
  case (type || sql_type(name))
  when :belongs_to
    { as: :select }.merge(search_form_field_collection(belongs_to(name)))

  when :belongs_to_polymorphic
    constant_pluralized = name.to_s.upcase
    constant = name.to_s.pluralize.upcase

    collection = nil

    if klass.respond_to?(:name)
      collection ||= (klass.const_get(constant) rescue nil) if defined?("#{klass.name}::#{constant}")
      collection ||= (klass.const_get(constant_pluralized) rescue nil) if defined?("#{klass.name}::#{constant_pluralized}")
    end

    if collection.present?
      { as: :select, polymorphic: true, collection: (collection || []) }
    else
      { as: :string }
    end
  when :has_and_belongs_to_many
    { as: :select }.merge(search_form_field_collection(has_and_belongs_to_many(name)))
  when :has_many
    { as: :select, multiple: true }.merge(search_form_field_collection(has_many(name)))
  when :has_one
    { as: :select, multiple: true }.merge(search_form_field_collection(has_one(name)))
  when :effective_addresses
    { as: :string }
  when :effective_roles
    { as: :select, collection: EffectiveRoles.roles }
  when :effective_obfuscation
    { as: :effective_obfuscation }
  when :boolean
    { as: :boolean, collection: [['Yes', true], ['No', false]] }
  when :datetime
    { as: :datetime }
  when :date
    { as: :date }
  when :integer
    { as: :number }
  when :text
    { as: :text }
  when :time
    { as: :time }
  when ActiveRecord::Base
    { as: :select }.merge(Effective::Resource.new(type).search_form_field_collection)
  else
    name = name.to_s

    # If the method is named :status, and there is a Class::STATUSES
    if ((klass || NilClass).const_defined?(name.pluralize.upcase) rescue false)
      { as: :select, collection: klass.const_get(name.pluralize.upcase) }
    elsif ((klass || NilClass).const_defined?(name.singularize.upcase) rescue false)
      { as: :select, collection: klass.const_get(name.singularize.upcase) }
    else
      { as: :string }
    end
  end
end

#search_form_field_collection(association = nil, limit: 100) ⇒ Object

Load the limit records + 1. If there are all there, return as: :string Otherwise return an Array of the processed results ready for a select field Only hit the database once



72
73
74
75
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
101
102
103
104
105
 
# File 'app/models/effective/resources/forms.rb', line 72

def search_form_field_collection(association = nil, limit: 100)
  res = (association.nil? ? self : Effective::Resource.new(association))

  # Return string if this isnt a relational thing
  klass = res.klass
  return { as: :string } unless klass.respond_to?(:unscoped)

  # Default scope
  scope = res.klass.unscoped

  scope = if scope.respond_to?(:datatables_scope)
    scope.datatables_scope
  elsif scope.respond_to?(:datatables_filter)
    scope.datatables_filter
  elsif scope.respond_to?(:shallow)
    scope.shallow
  elsif scope.respond_to?(:sorted)
    scope.sorted
  else
    scope
  end

  scope = scope.unarchived if scope.respond_to?(:unarchived)

  # Now that we have the scope figured out let's pull the limit number of records into an Array
  # If there are more than the limit, return as: :string
  resources = scope.limit(limit).to_a
  return { as: :string } unless resources.length < limit

  # Otherwise there are less than the limit, so we can use a collection select
  {
    collection: resources.map { |obj| [obj.to_s, obj.id] }
  }
end