Module: CamaleonCms::CustomFieldsRead

Extended by:
ActiveSupport::Concern
Included in:
PostDefault, TermTaxonomy
Defined in:
app/models/concerns/camaleon_cms/custom_fields_read.rb

Instance Method Summary collapse

Instance Method Details

#add_custom_field_group(values, kind = "Post") ⇒ Object Also known as: add_field_group

Model supported: PostType, Category, Post, Posttag, Widget, Plugin, Theme, User and Custom models pre configured Note 1: If you need add fields for all post’s or all categories, then you need to add the fields into the

post_type.add_custom_field_group(values, kind = "Post")
post_type.add_custom_field_group(values, kind = "Category")

Note 2: If you need add fields for only the Post_type, you have to use options or metas return: CustomFieldGroup object kind: argument only for PostType model: (Post | Category | PostTag), default => Post. If kind = “” this will add group for all post_types



150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 150

def add_custom_field_group(values, kind = "Post")
  values = values.with_indifferent_access
  group = get_field_groups(kind).where(slug: values[:slug]).first
  unless group.present?
    site = _cama_get_field_site
    values[:parent_id] = site.id if site.present?
    if self.is_a?(CamaleonCms::Post) # harcoded for post to support custom field groups
      group = CamaleonCms::CustomFieldGroup.where(object_class: "Post", objectid: self.id).create!(values)
    else
      group = get_field_groups(kind).create!(values)
    end
  end
  group
end

#add_custom_field_to_default_group(item, options, kind = "Post") ⇒ Object Also known as: add_field

Add custom fields for a default group: This will create a new group with slug=_default if it doesn’t exist yet more details in add_manual_field(item, options) from custom field groups kind: argument only for PostType model: (Post | Category | PostTag), default => Post



170
171
172
173
174
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 170

def add_custom_field_to_default_group(item, options, kind = "Post")
  g = get_field_groups(kind).where(slug: "_default").first
  g = add_custom_field_group({name: "Default Field Group", slug: "_default"}, kind) unless g.present?
  g.add_manual_field(item, options)
end

#get_field_groups(args = {}) ⇒ Object

Sample: mypost.get_field_groups() ==> return fields for posts from parent posttype Sample: mycat.get_field_groups() ==> return fields for categories from parent posttype Sample: myposttag.get_field_groups() ==> return fields for posttags from parent posttype Sample: mypost_type.get_field_groups(‘Post’) => return custom fields for posts Sample: mypost_type.get_field_groups(‘Category’) => return custom fields for posts Sample: mypost_type.get_field_groups(‘PostTag’) => return custom fields for posts



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 29

def get_field_groups(args = {})
  args = args.is_a?(String) ?  {kind: args, include_parent: false } : {kind: "Post", include_parent: false }.merge(args)
  class_name = self.class.to_s.parseCamaClass
  case class_name
    when 'Category','PostTag'
      self.post_type.get_field_groups(class_name)
    when 'Post'
      CamaleonCms::CustomFieldGroup.where("(objectid = ? AND object_class = ?) OR (objectid = ? AND object_class = ?)", self.id || -1, class_name, self.post_type.id, "PostType_#{class_name}")
    when 'NavMenuItem'
      self.main_menu.field_groups
    when 'PostType'
      if args[:kind] == "all"
        CamaleonCms::CustomFieldGroup.where(object_class: ["PostType_Post", "PostType_Post", "PostType_PostTag", "PostType"], objectid:  self.id )
      elsif args[:kind] == "post_type"
        self.field_groups
      else
        CamaleonCms::CustomFieldGroup.where(object_class: "PostType_#{args[:kind]}", objectid:  self.id )
      end
    else # 'Plugin' or other classes
      self.field_groups
  end
end

#get_field_object(slug) ⇒ Object

return field object for current model



178
179
180
181
182
183
184
185
186
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 178

def get_field_object(slug)
  CamaleonCms::CustomField.where(
    slug: slug,
    parent_id: get_field_groups.pluck(:id),
  ).first || CamaleonCms::CustomField.where(
    slug: slug,
    parent_id: get_field_groups({include_parent: true})
  ).first
end

#get_field_value(_key, _default = nil, group_number = 0) ⇒ Object Also known as: get_field, get_field!

get custom field value _key: custom field key if value is not present, then return default return default only if the field was not registered



64
65
66
67
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 64

def get_field_value(_key, _default = nil, group_number = 0)
  v = get_field_values(_key, group_number).first rescue _default
  v.present? ? v : _default
end

#get_field_values(_key, group_number = 0) ⇒ Object Also known as: get_fields

get custom field values _key: custom field key



73
74
75
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 73

def get_field_values(_key, group_number = 0)
  field_values.loaded? ? field_values.select{|f| f.custom_field_slug == key && f.group_number == group_number}.map{|f| f.value } : field_values.where(custom_field_slug: _key, group_number: group_number).pluck(:value)
end

#get_field_values_hash(include_options = false) ⇒ Object

return all values “single value”, key2: [multiple, values], key3: value4 if include_options = false {values: “single value”, options: {a:1, b: 4}, key2: [multiple, values], options: {a=1, b=2 }} if include_options = true



110
111
112
113
114
115
116
117
118
119
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 110

def get_field_values_hash(include_options = false)
  fields = {}
  self.field_values.to_a.uniq.each do |field_value|
    custom_field = field_value.custom_fields
    values = custom_field.values.where(objectid: self.id).pluck(:value)
    fields[field_value.custom_field_slug] = custom_field.cama_options[:multiple].to_s.to_bool ? values : values.first unless include_options
    fields[field_value.custom_field_slug] = {values: custom_field.cama_options[:multiple].to_s.to_bool ? values : values.first, options: custom_field.cama_options, id: custom_field.id} if include_options
  end
  fields.to_sym
end

#get_fields_grouped(field_keys) ⇒ Object

return the values of custom fields grouped by group_number field_keys: (array of keys) samples: my_object.get_fields_grouped([‘my_slug1’, ‘my_slug2’])

return: [
          { 'my_slug1' => ["val 1"], 'my_slug2' => ['val 2']},
          { 'my_slug1' => ["val2 for slug1"], 'my_slug2' => ['val 2 for slug2']}
] ==> 2 groups

return: [
          { 'my_slug1' => ["val 1", 'val 2 for fields multiple support'], 'my_slug2' => ['val 2']},
          { 'my_slug1' => ["val2 for slug1", 'val 2'], 'my_slug2' => ['val 2 for slug2']}
          { 'my_slug1' => ["val3 for slug1", 'val 3'], 'my_slug2' => ['val 3 for slug2']}
] ==> 3 groups

puts res[0]['my_slug1'].first ==> "val 1"



93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 93

def get_fields_grouped(field_keys)
  res = []
  field_values.where(custom_field_slug: field_keys).order(group_number: :asc).group_by(&:group_number).each do |group_number, group_fields|
    group = {}
    field_keys.each do |field_key|
      _tmp = []
      group_fields.each{ |field| _tmp << field.value if field_key == field.custom_field_slug }
      group[field_key] = _tmp if _tmp.present?
    end
    res << group
  end
  res
end

#get_fields_object(f = true) ⇒ Object

return all custom fields for current element {options: {, values: [], name: ”, …} } deprecated f attribute



124
125
126
127
128
129
130
131
132
133
134
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 124

def get_fields_object(f=true)
  fields = {}
  self.field_values.eager_load(:custom_fields).to_a.uniq.each do |field_value|
    custom_field = field_value.custom_fields
    # if custom_field.options[:show_frontend].to_s.to_bool
    values = custom_field.values.where(objectid: self.id).pluck(:value)
    fields[field_value.custom_field_slug] = custom_field.attributes.merge(options: custom_field.cama_options, values: custom_field.cama_options[:multiple].to_s.to_bool ? values : values.first)
    # end
  end
  fields.to_sym
end

#get_user_field_groups(site) ⇒ Object

get custom field groups for current user return collections CustomFieldGroup site: site object



55
56
57
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 55

def get_user_field_groups(site)
  site.custom_field_groups.where(object_class: self.class.to_s.parseCamaClass)
end

#save_field_value(key, value, order = 0, clear = true) ⇒ Object

Set custom field values for current model key: slug of the custom field value: array of values for multiple values support value: string value



220
221
222
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 220

def save_field_value(key, value, order = 0, clear = true)
  set_field_value(key, value, {clear: clear, order: order})
end

#set_field_value(key, value, args = {}) ⇒ Object

Set custom field values for current model (support for multiple group values) key: (string required) slug of the custom field value: (array | string) array: array of values for multiple values support, string: uniq value for the custom field args:

field_id: (integer optional) identifier of the custom field
order: order or position of the field value
group_number: number of the group (only for custom field group with is_repeat enabled)
clear: (boolean, default true) if true, will remove previous values and set these values, if not will append values

return false if the was not saved because there is not present the field with slug: key sample: my_post.set_field_value(‘subtitle’, ‘Sub Title’) sample: my_post.set_field_value(‘subtitle’, [‘Sub Title1’, ‘Sub Title2’]) # set values for a field (for fields that support multiple values) sample: my_post.set_field_value(‘subtitle’, ‘Sub Title’, 1) sample: my_post.set_field_value(‘subtitle’, ‘Sub Title’, 1, group_number: 1) # add field values for fields in group 1



237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 237

def set_field_value(key, value, args = {})
  args = {order: 0, group_number: 0, field_id: nil, clear: true}.merge(args)
  args[:field_id] = get_field_object(key).id rescue nil unless args[:field_id].present?
  unless args[:field_id].present?
    raise ArgumentError, "There is no custom field configured for #{key}"
  end
  self.field_values.where({custom_field_slug: key, group_number: args[:group_number]}).delete_all if args[:clear]
  v = {custom_field_id: args[:field_id], custom_field_slug: key, value: fix_meta_value(value), term_order: args[:order], group_number: args[:group_number]}
  if value.is_a?(Array)
    value.each do |val|
      self.field_values.create!(v.merge({value: fix_meta_value(val)}))
    end
  else
    self.field_values.create!(v)
  end
end

#set_field_values(datas = {}) ⇒ Object

save all fields sent from browser (reservated for browser request) sample: 

"0"=>{ "untitled-text-box"=>{"id"=>"262", "values"=>{"0"=>"33333"}},
"1"=>{ "untitled-text-box"=>"values"=>{"0"=>"33333"}}

}



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 194

def set_field_values(datas = {})
  if datas.present?
    self.field_values.delete_all
    datas.each do |index, fields_data|
      fields_data.each do |field_key, values|
        if values[:values].present?
          order_value = -1
          ((values[:values].is_a?(Hash) || values[:values].is_a?(ActionController::Parameters)) ? values[:values].values : values[:values]).each do |value|
            item = self.field_values.create!({custom_field_id: values[:id], custom_field_slug: field_key, value: fix_meta_value(value), term_order: order_value += 1, group_number: values[:group_number] || 0})
          end
        end
      end
    end
  end
end

#update_field_value(_key, value = nil, group_number = 0) ⇒ Object

update new value for field with slug _key Sample: my_posy.update_field_value(‘sub_title’, ‘Test Sub Title’)



212
213
214
 
# File 'app/models/concerns/camaleon_cms/custom_fields_read.rb', line 212

def update_field_value(_key, value = nil, group_number = 0)
  self.field_values.where(custom_field_slug: _key, group_number: group_number).first.update_column('value', value) rescue nil
end