Module: Avo::Concerns::HasItems

Extended by:
ActiveSupport::Concern
Included in:
BaseAction, BaseResource, Resources::Items::ItemGroup, Resources::Items::Row, Resources::Items::Sidebar, Resources::Items::Tab, Resources::Items::TabGroup
Defined in:
lib/avo/concerns/has_items.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#items_holder ⇒ Object 



52
53
54
 
# File 'lib/avo/concerns/has_items.rb', line 52

def items_holder
  @items_holder || Avo::Resources::Items::Holder.new
end

Instance Method Details

#fields(**args) ⇒ Object 



72
73
74
 
# File 'lib/avo/concerns/has_items.rb', line 72

def fields(**args)
  self.class.fields(**args)
end

#get_field(id) ⇒ Object 



187
188
189
190
191
 
# File 'lib/avo/concerns/has_items.rb', line 187

def get_field(id)
  get_field_definitions.find do |f|
    f.id == id.to_sym
  end
end

#get_field_definitions(only_root: false) ⇒ Object 



125
126
127
128
129
 
# File 'lib/avo/concerns/has_items.rb', line 125

def get_field_definitions(only_root: false)
  only_fields(only_root: only_root).map do |field|
    field.hydrate(resource: self, user: user, view: view)
  end
end

#get_fields(panel: nil, reflection: nil, only_root: false) ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
# File 'lib/avo/concerns/has_items.rb', line 137

def get_fields(panel: nil, reflection: nil, only_root: false)
  fields = get_field_definitions(only_root: only_root)
    .select do |field|
      # Get the fields for this view
      field.visible_in_view?(view: view)
    end
    .select do |field|
      field.visible?
    end
    .select do |field|
      is_valid = true

      # Strip out the reflection field in index queries with a parent association.
      if reflection.present?
        # regular non-polymorphic association
        # we're matching the reflection inverse_of foriegn key with the field's foreign_key
        if field.is_a?(Avo::Fields::BelongsToField)
          if field.respond_to?(:foreign_key) &&
              reflection.inverse_of.present? &&
              reflection.inverse_of.respond_to?(:foreign_key) &&
              reflection.inverse_of.foreign_key == field.foreign_key
            is_valid = false
          end

          # polymorphic association
          if field.respond_to?(:foreign_key) &&
              field.is_polymorphic? &&
              reflection.respond_to?(:polymorphic?) &&
              reflection.inverse_of.respond_to?(:foreign_key) &&
              reflection.inverse_of.foreign_key == field.reflection.foreign_key
            is_valid = false
          end
        end
      end

      is_valid
    end

  if panel.present?
    fields = fields.select do |field|
      field.panel_name == panel
    end
  end

  # hydrate_fields fields
  fields.map do |field|
    field.dup.hydrate(record: @record, view: @view, resource: self)
  end
end

#get_items ⇒ Object 



193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/avo/concerns/has_items.rb', line 193

def get_items
  # Each group is built only by standalone items or items that have their own panel, keeping the items order
  grouped_items = visible_items.slice_when do |prev, curr|
    # Slice when the item type changes from standalone to panel or vice-versa
    is_standalone?(prev) != is_standalone?(curr)
  end.to_a.map do |group|
    { elements: group, is_standalone: is_standalone?(group.first) }
  end

  # Creates a main panel if it's missing and adds first standalone group of items if present
  if items.none? { |item| item.is_main_panel? }
    if (standalone_group = grouped_items.find { |group| group[:is_standalone] }).present?
      calculated_main_panel = Avo::Resources::Items::MainPanel.new
      hydrate_item calculated_main_panel
      calculated_main_panel.items_holder.items = standalone_group[:elements]
      grouped_items[grouped_items.index standalone_group] = { elements: [calculated_main_panel], is_standalone: false }
    end
  end

  # For each standalone group, wrap items in a panel
  grouped_items.select { |group| group[:is_standalone] }.each do |group|
    calculated_panel = Avo::Resources::Items::Panel.new
    calculated_panel.items_holder.items = group[:elements]
    hydrate_item calculated_panel
    group[:elements] = calculated_panel
  end

  grouped_items.flat_map { |group| group[:elements] }
end

#get_preview_fields ⇒ Object 



131
132
133
134
135
 
# File 'lib/avo/concerns/has_items.rb', line 131

def get_preview_fields
  get_field_definitions.select do |field|
    field.visible_in_view?(view: :preview)
  end
end

#invalid_fields ⇒ Object

def items

items_holder.items

end



60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/avo/concerns/has_items.rb', line 60

def invalid_fields
  invalid_fields = items_holder.invalid_fields

  items_holder.items.each do |item|
    if item.respond_to? :items
      invalid_fields += item.invalid_fields
    end
  end

  invalid_fields
end

#is_empty? ⇒ Boolean

Returns:

  • (Boolean) 


291
292
293
 
# File 'lib/avo/concerns/has_items.rb', line 291

def is_empty?
  visible_items.blank?
end

#items ⇒ Object 



223
224
225
 
# File 'lib/avo/concerns/has_items.rb', line 223

def items
  items_holder&.items || []
end

#only_fields(only_root: false) ⇒ Object

Dives deep into panels and tabs to fetch all the fields for a resource.



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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/avo/concerns/has_items.rb', line 81

def only_fields(only_root: false)
  fields = []

  items.each do |item|
    next if item.nil?

    if only_root
      # When `item.is_main_panel? == true` then also `item.is_panel? == true`
      # But when only_root == true we want to extract main_panel items
      # In all other circumstances items will get extracted when checking for `item.is_panel?`
      if item.is_main_panel?
        fields << extract_fields(item)
      end
    else
      # Dive into panels to fetch their fields
      if item.is_panel?
        fields << extract_fields(item)
      end

      # Dive into tabs to fetch their fields
      if item.is_tab_group?
        item.items.map do |tab|
          fields << extract_fields(tab)
        end
      end

      # Dive into sidebar to fetch their fields
      if item.is_sidebar?
        fields << extract_fields(item)
      end
    end

    if item.is_field?
      fields << item
    end

    if item.is_row?
      fields << extract_fields(tab)
    end
  end

  fields.flatten
end

#tab_groups ⇒ Object 



76
77
78
 
# File 'lib/avo/concerns/has_items.rb', line 76

def tab_groups
  self.class.tab_groups
end

#visible_items ⇒ Object 



227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
 
# File 'lib/avo/concerns/has_items.rb', line 227

def visible_items
  items
    .map do |item|
      hydrate_item item

      if item.is_a? Avo::Resources::Items::TabGroup
        # Set the target to _top for all belongs_to fields in the tab group
        item.items.grep(Avo::Resources::Items::Tab).each do |tab|
          tab.items.grep(Avo::Resources::Items::Panel).each do |panel|
            set_target_to_top panel.items.grep(Avo::Fields::BelongsToField)

            panel.items.grep(Avo::Resources::Items::Row).each do |row|
              set_target_to_top row.items.grep(Avo::Fields::BelongsToField)
            end
          end
        end
      end

      item
    end
    .select do |item|
      item.visible?
    end
    .select do |item|
      if item.respond_to?(:visible_in_view?)
        item.visible_in_view? view: view
      else
        true
      end
    end
    .select do |item|
      # Check if record has the setter method
      # Next if the view is not on forms
      next true if !view.in?(%w[edit update new create])

      # Skip items that don't have an id
      next true if !item.respond_to?(:id)

      # Skip tab groups and tabs
      # Skip headings
      # Skip location fields
      # On location field we can have field coordinates and setters with different names
      #   like latitude and longitude
      next true if item.is_a?(Avo::Resources::Items::TabGroup) ||
        item.is_a?(Avo::Resources::Items::Tab) ||
        item.is_heading? ||
        item.is_a?(Avo::Fields::LocationField)

      item.resource.record.respond_to?(:"#{item.try(:for_attribute) || item.id}=")
    end
    .select do |item|
      # Check if the user is authorized to view it.
      # This is usually used for has_* fields
      if item.respond_to? :authorized?
        item.authorized?
      else
        true
      end
    end
    .select do |item|
      !item.is_a?(Avo::Resources::Items::Sidebar)
    end.compact
end