Class: ScribblerGroup

Inherits:
ActiveRecord::Base
  • Object
show all
Defined in:
app/models/scribbler_group.rb

Constant Summary collapse

ELEMENTS =

Konstanten

{:row => "ScribblerText",
          :text => "ScribblerText",
          :link => "ScribblerLink",
          :image => "ScribblerImage",
          :var => "ScribblerVar"
}

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#group_data ⇒ Object

Configuration



4
5
6
 
# File 'app/models/scribbler_group.rb', line 4

def group_data
  @group_data
end

Instance Method Details

#clone!(new_name) ⇒ Object 



76
77
78
79
80
81
82
83
 
# File 'app/models/scribbler_group.rb', line 76

def clone!(new_name)
  group = self.class.new(:name => new_name, :container_id => self.container_id)
  if group.save
    self.elements.each do |el|
      el.class.create(el.attributes.except("id").merge(:group_id => group.id))
    end
  end
end

#container_description ⇒ Object 



163
164
165
 
# File 'app/models/scribbler_group.rb', line 163

def container_description
  container.description
end

#contents ⇒ Object

> END



34
35
36
37
38
 
# File 'app/models/scribbler_group.rb', line 34

def contents
  contents = ELEMENTS.values.map do |cont_class|
    cont_class.constantize.where(group_id: self.id).where(:released => true)
  end.flatten
end

#destroy_elements ⇒ Object 



127
128
129
 
# File 'app/models/scribbler_group.rb', line 127

def destroy_elements
  self.elements.each {|e| e.destroy }
end

#elements(options = {:released => true}) ⇒ Object 



115
116
117
 
# File 'app/models/scribbler_group.rb', line 115

def elements(options = {:released => true})
  ELEMENTS.values.map(&:constantize).uniq.map {|c| c.where(:group_id => self.id, :released => options[:released] == true)}.flatten.sort_by {|e| e.human_name}
end

#get_element(type, name, options = {:released => true}) ⇒ Object

Helpers



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
 
# File 'app/models/scribbler_group.rb', line 87

def get_element(type, name, options = {:released => true})
  options[:released] ||= true

  case type
  when :row
    options.merge!(:plain => true)
  when :text
    options.merge!(:plain => false)
  when :link
    # ...
  when :image

  end

  options.merge!(:name => name, :group_id => self.id)

  element_class = ELEMENTS[(type.is_a?(String) ? type.constantize : type)]
  if element_class.is_a?(String)
    element_class = element_class.constantize
  end
  element = element_class.where(options).first
  if element.nil?
    element = element_class.create(options)
  end

  return element
end

#human_name ⇒ Object 



159
160
161
 
# File 'app/models/scribbler_group.rb', line 159

def human_name
  self.human_name_de.presence || (I18n.t(self.name, :scope => "scribbler.group_names", :default => self.name.humanize) rescue self.name)
end

#image(image_name, options = {}) ⇒ Object 



63
64
65
66
67
68
69
70
 
# File 'app/models/scribbler_group.rb', line 63

def image(image_name, options = {})
  e = get_element(:image, image_name, options)
  if e.image
    e.image.url
  else
    ""
  end
end

#link(link_name, options = {}) ⇒ Object 



57
58
59
60
61
 
# File 'app/models/scribbler_group.rb', line 57

def link(link_name, options = {})
  link = get_element(:link, link_name)
  options.merge!(:target => "_blank") if link.external
  ActionController::Base.helpers.link_to(link.title, link.url, options)
end

#process_data!(data) ⇒ Object 



144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'app/models/scribbler_group.rb', line 144

def process_data!(data)
  data.each do |key, content|
    content.to_hash.symbolize_keys!
    e_id    = content.delete(:id)
    e_type  = content.delete(:type)
    e_rel   = content.delete(:release)
    element = ELEMENTS[e_type.to_sym].constantize.find(e_id)
    element.update_attributes(content)

    if e_rel == "1"
      element.release!
    end
  end
end

#process_group_data(data = {}) ⇒ Object

Save data



136
137
138
139
140
141
142
 
# File 'app/models/scribbler_group.rb', line 136

def process_group_data(data = {})
  # Update realesed data
  self.process_data!(data[:released])

  # Update unrealesed data
  self.process_data!(data[:unreleased]) if data[:unreleased]
end

#released_elements ⇒ Object 



119
120
121
 
# File 'app/models/scribbler_group.rb', line 119

def released_elements
  self.elements(:released => true)
end

#row(row_name, options = {}) ⇒ Object

Display data



41
42
43
44
45
46
47
 
# File 'app/models/scribbler_group.rb', line 41

def row(row_name, options = {})
  e = get_element(:row, row_name)
  if e.content.blank? && options[:default]
    e.update_attributes(:content => options[:default])
  end
  return e.content.to_s.html_safe
end

#text(text_name, options = {}) ⇒ Object 



49
50
51
52
53
54
55
 
# File 'app/models/scribbler_group.rb', line 49

def text(text_name, options = {})
  e = get_element(:text, text_name)
  if e.content.blank? && options[:default]
    e.update_attributes(:content => options[:default])
  end
  return e.content.to_s.html_safe
end

#unreleased_elements ⇒ Object 



123
124
125
 
# File 'app/models/scribbler_group.rb', line 123

def unreleased_elements
  self.elements(:released => false)
end

#var(name, options = {}) ⇒ Object 



72
73
74
 
# File 'app/models/scribbler_group.rb', line 72

def var(name, options = {})
  get_element :var, name
end