Module: Avo::Concerns::HasItems

Extended by:
ActiveSupport::Concern
Included in:
BaseAction, FieldsExecutionContext, Resources::Base, 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 



54
55
56
 
# File 'lib/avo/concerns/has_items.rb', line 54

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

Instance Method Details

#fields(**args) ⇒ Object 



74
75
76
 
# File 'lib/avo/concerns/has_items.rb', line 74

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

#get_field(id) ⇒ Object 



198
199
200
201
202
 
# File 'lib/avo/concerns/has_items.rb', line 198

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

#get_field_definitions(only_root: false) ⇒ Object 



127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/avo/concerns/has_items.rb', line 127

def get_field_definitions(only_root: false)
  only_fields(only_root:).map do |field|
    # When nested field hydrate the field with the nested resource
    resource = if field.try(:nested_on?, view)
      Avo.resource_manager.get_resource_by_model_class(model_class.reflections[field.id.to_s].klass)
        .new(view:, params:)
        .detect_fields
    else
      self
    end

    field.hydrate(resource:, user:, view:, record: resource.record)
  end
end

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



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
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/avo/concerns/has_items.rb', line 148

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 



204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/avo/concerns/has_items.rb', line 204

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 



142
143
144
145
146
 
# File 'lib/avo/concerns/has_items.rb', line 142

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



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

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) 


305
306
307
 
# File 'lib/avo/concerns/has_items.rb', line 305

def is_empty?
  visible_items.blank?
end

#items ⇒ Object 



234
235
236
 
# File 'lib/avo/concerns/has_items.rb', line 234

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.



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
124
125
 
# File 'lib/avo/concerns/has_items.rb', line 83

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(item)
    end
  end

  fields.flatten
end

#tab_groups ⇒ Object 



78
79
80
 
# File 'lib/avo/concerns/has_items.rb', line 78

def tab_groups
  self.class.tab_groups
end

#visible_items ⇒ Object 



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
290
291
292
293
294
295
296
297
298
299
300
301
302
303
 
# File 'lib/avo/concerns/has_items.rb', line 238

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)

      # Skip nested fields
      next true if item.try(:nested_on?, view)

      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