Module: Avo::Concerns::HasItems

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



20
21
22
 
# File 'lib/avo/concerns/has_items.rb', line 20

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

Instance Method Details

#fields(**args) ⇒ Object 



40
41
42
 
# File 'lib/avo/concerns/has_items.rb', line 40

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

#get_field(id) ⇒ Object 



164
165
166
167
168
 
# File 'lib/avo/concerns/has_items.rb', line 164

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

#get_field_definitions(only_root: false) ⇒ Object 



93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/avo/concerns/has_items.rb', line 93

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 



114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
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
 
# File 'lib/avo/concerns/has_items.rb', line 114

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

Default renderable items for any HasItems container. Subclasses that need to auto-wrap (Tab, Panel, Sidebar, Resource) override this. Card and TabGroup fall through to the raw visible_items.



173
174
175
 
# File 'lib/avo/concerns/has_items.rb', line 173

def get_items
  visible_items
end

#get_preview_fields ⇒ Object 



108
109
110
111
112
 
# File 'lib/avo/concerns/has_items.rb', line 108

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



28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/avo/concerns/has_items.rb', line 28

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) 


272
273
274
 
# File 'lib/avo/concerns/has_items.rb', line 272

def is_empty?
  visible_items.blank?
end

#items ⇒ Object 



201
202
203
 
# File 'lib/avo/concerns/has_items.rb', line 201

def items
  items_holder&.items || []
end

#items_with_standalone_fields_wrapped_in_cards ⇒ Object

Groups consecutive “standalone” fields (fields that don’t bring their own panel — text, select, date, etc.) into cards, so containers like Panel/Sidebar/Tab render a nice card background around them even when the user forgot to write ‘card do … end` themselves. Fields that have their own panel (has_many, has_and_belongs_to_many, has_one, belongs_to) and explicit panels/cards pass through untouched and break the run, so you get separate cards around each group.



184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'lib/avo/concerns/has_items.rb', line 184

def items_with_standalone_fields_wrapped_in_cards
  grouped_items = visible_items.slice_when do |prev, curr|
    is_standalone?(prev) != is_standalone?(curr)
  end.to_a.map do |group|
    {elements: group, is_standalone: is_standalone?(group.first)}
  end

  grouped_items.select { |group| group[:is_standalone] }.each do |group|
    card = Avo::Resources::Items::Card.new
    hydrate_item card
    card.items_holder.items = group[:elements]
    group[:elements] = card
  end

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

#only_fields(only_root: false) ⇒ Object

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



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/avo/concerns/has_items.rb', line 49

def only_fields(only_root: false)
  fields = []

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

    if only_root
      # When only_root == true we want to extract the panel and card items
      if item.is_panel? || item.is_card?
        if item.visible_in_view?(view: view)
          fields << extract_fields(item)
        end
      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

      if item.is_card?
        fields << extract_fields(item)
      end
    end

    if item.is_field?
      fields << item
    end
  end

  fields.flatten
end

#tab_groups ⇒ Object 



44
45
46
 
# File 'lib/avo/concerns/has_items.rb', line 44

def tab_groups
  self.class.tab_groups
end

#visible_items ⇒ Object 



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

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)
          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.is_header?

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

      # When the resource is a form, we want to show all items even if there is no setter method
      next true if defined?(Avo::Forms::Core::Resources::FormResource) && try(:resource).is_a?(Avo::Forms::Core::Resources::FormResource)

      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