Class: Page

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

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.find_live_by_path(path) ⇒ Object 



250
251
252
 
# File 'app/models/page.rb', line 250

def self.find_live_by_path(path)
  published.not_archived.first(:conditions => {:path => path})
end

Instance Method Details

#after_build_new_version(new_version) ⇒ Object 



56
57
58
59
60
61
62
63
 
# File 'app/models/page.rb', line 56

def after_build_new_version(new_version)
  copy_connectors(
    :from_version_number => @copy_connectors_from_version || (new_version.version - 1),
    :to_version_number => new_version.version
  )
  @copy_connectors_from_version = nil
  true
end

#after_publish ⇒ Object

Publish all



66
67
68
69
70
71
72
73
 
# File 'app/models/page.rb', line 66

def after_publish
  self.reload # Get's the correct version number loaded
  self.connectors.for_page_version(self.version).all(:order => "position").each do |c| 
    if c.connectable_type.constantize.publishable? && con = c.connectable
      con.publish
    end
  end
end

#ancestors ⇒ Object 



226
227
228
 
# File 'app/models/page.rb', line 226

def ancestors
  section_node.ancestors
end

#append_leading_slash_to_path ⇒ Object 



199
200
201
202
203
204
205
 
# File 'app/models/page.rb', line 199

def append_leading_slash_to_path
  if path.blank?
    self.path = "/"
  elsif path[0,1] != "/"
    self.path = "/#{path}"
  end
end

#assigned_to ⇒ Object 



271
272
273
 
# File 'app/models/page.rb', line 271

def assigned_to
  current_task ? current_task.assigned_to : nil
end

#assigned_to?(user) ⇒ Boolean

Returns:

  • (Boolean) 


275
276
277
 
# File 'app/models/page.rb', line 275

def assigned_to?(user)
  assigned_to == user
end

#connectable_count_for_container(container) ⇒ Object

Returns the number of connectables in the given container for this version of this page



246
247
248
 
# File 'app/models/page.rb', line 246

def connectable_count_for_container(container)
  connectors.for_page_version(version).in_container(container.to_s).count
end

#container_published?(container) ⇒ Boolean

Returns true if the block attached to each connector in the given container are published

Returns:

  • (Boolean) 


239
240
241
242
243
 
# File 'app/models/page.rb', line 239

def container_published?(container)
  connectors.for_page_version(draft.version).in_container(container.to_s).all? do |c| 
    c.connectable_type.constantize.publishable? ? c.connectable.live? : true
  end
end

#copy_connectors(options = {}) ⇒ Object 



75
76
77
78
79
80
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
 
# File 'app/models/page.rb', line 75

def copy_connectors(options={})
  connectors.for_page_version(options[:from_version_number]).all(:order => "connectors.container, connectors.position").each do |c|
    # The connector won't have a connectable if it has been deleted
    # Also need to see if the draft has been deleted,
    # in which case we are in the process of deleting it
    if c.should_be_copied?
      connectable = c.connectable_type.constantize.versioned? ? c.connectable.as_of_version(c.connectable_version) : c.connectable
    
      version = connectable.class.versioned? ? connectable.version : nil

      #If we are copying connectors from a previous version, that means we are reverting this page,
      #in which case we should create a new version of the block, and connect this page to that block.
      #If the connectable is versioned, the connector needs to reference the newly drafted connector
      #that is created during the revert_to method
      if @copy_connectors_from_version && connectable.class.versioned? && (connectable.version != connectable.draft.version)
        connectable = connectable.class.find(connectable.id)
        connectable.updated_by_page = self
        connectable.revert_to(c.connectable_version)
        version = connectable.class.versioned? ? connectable.draft.version : nil
      end      
    
      new_connector = connectors.build(
        :page_version => options[:to_version_number], 
        :connectable => connectable, 
        :connectable_version => version,         
        :container => c.container, 
        :position => c.position
      )
    end
  end
  true
end

#create_connector(connectable, container) ⇒ Object 



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'app/models/page.rb', line 108

def create_connector(connectable, container)
  transaction do
    raise "Connectable is nil" unless connectable
    raise "Container is required" if container.blank?
    update_attributes(
      :version_comment => "#{connectable} was added to the '#{container}' container",
      :publish_on_save => (
        published? && 
        connectable.connected_page && 
        (connectable.class.publishable? ? connectable.published? : true)))
    connectors.create(
      :page_version => draft.version,
      :connectable => connectable,
      :connectable_version => connectable.class.versioned? ? connectable.version : nil, 
      :container => container)      
  end
end

#current_task ⇒ Object 



267
268
269
 
# File 'app/models/page.rb', line 267

def current_task
  tasks.incomplete.first
end

#delete_connectors ⇒ Object 



156
157
158
 
# File 'app/models/page.rb', line 156

def delete_connectors
  connectors.for_page_version(version).all.each{|c| c.destroy }
end

#file_size ⇒ Object 



167
168
169
 
# File 'app/models/page.rb', line 167

def file_size
  "?"
end

#in_section?(section_or_section_name) ⇒ Boolean

Returns:

  • (Boolean) 


230
231
232
233
234
235
236
 
# File 'app/models/page.rb', line 230

def in_section?(section_or_section_name)
  sec = section_or_section_name.is_a?(String) ? 
    Section.first(:conditions => {:name => section_or_section_name}) : 
    section_or_section_name
  fn = lambda{|s| s ? (s == sec || fn.call(s.parent)) : false}
  fn.call(section)
end

#layout ⇒ Object 



213
214
215
 
# File 'app/models/page.rb', line 213

def layout
  template_file_name && "templates/#{template_file_name.split('.').first}"
end

#move_connector(connector, direction) ⇒ Object 



126
127
128
129
130
131
132
133
134
 
# File 'app/models/page.rb', line 126

def move_connector(connector, direction)
  transaction do
    raise "Connector is nil" unless connector
    raise "Direction is nil" unless direction
    orientation = direction[/_/] ? "#{direction.sub('_', ' the ')} of" : "#{direction} within"
    update_attributes(:version_comment => "#{connector.connectable} was moved #{orientation} the '#{connector.container}' container")
    connectors.for_page_version(draft.version).like(connector).first.send("move_#{direction}")
  end    
end

#name_with_section_path ⇒ Object 



254
255
256
257
 
# File 'app/models/page.rb', line 254

def name_with_section_path
  a = ancestors
  (a[1..a.size].map{|a| a.name} + [name]).join(" / ")
end

#page_title ⇒ Object 



195
196
197
 
# File 'app/models/page.rb', line 195

def page_title
  title.blank? ? name : title
end

#path_not_reserved ⇒ Object 



207
208
209
210
211
 
# File 'app/models/page.rb', line 207

def path_not_reserved
  if Cms.reserved_paths.include?(path)
    errors.add(:path, "is invalid, '#{path}' a reserved path")
  end
end

#public? ⇒ Boolean

Returns:

  • (Boolean) 


191
192
193
 
# File 'app/models/page.rb', line 191

def public?
  section ? section.public? : false
end

#remove_connector(connector) ⇒ Object 



142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'app/models/page.rb', line 142

def remove_connector(connector)
  transaction do
    raise "Connector is nil" unless connector
    update_attributes(:version_comment => "#{connector.connectable} was removed from the '#{connector.container}' container")
    
    #The logic of this is to go ahead and let the container get copied forward, then delete the new connector
    if new_connector = connectors.for_page_version(draft.version).like(connector).first
      new_connector.destroy
    else
      raise "Error occurred while trying to remove connector #{connector.id}"
    end
  end
end

#revert_to(version) ⇒ Object

This is done to let copy_connectors know which version to pull from copy_connectors will get called later as an after_update callback



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

def revert_to(version)
  @copy_connectors_from_version = version
  super(version)
end

#section ⇒ Object 



175
176
177
 
# File 'app/models/page.rb', line 175

def section
  section_node ? section_node.section : nil
end

#section=(sec) ⇒ Object 



183
184
185
186
187
188
189
 
# File 'app/models/page.rb', line 183

def section=(sec)
  if section_node
    section_node.move_to_end(sec)
  else
    build_section_node(:node => self, :section => sec)
  end      
end

#section_id ⇒ Object 



171
172
173
 
# File 'app/models/page.rb', line 171

def section_id
  section ? section.id : nil
end

#section_id=(sec_id) ⇒ Object 



179
180
181
 
# File 'app/models/page.rb', line 179

def section_id=(sec_id)
  self.section = Section.find(sec_id)
end

#template ⇒ Object

This will be nil if it is a file system based template



218
219
220
 
# File 'app/models/page.rb', line 218

def template
  PageTemplate.find_by_file_name(template_file_name)
end

#template_name ⇒ Object 



222
223
224
 
# File 'app/models/page.rb', line 222

def template_name
  template_file_name && PageTemplate.display_name(template_file_name)
end

#top_level_section ⇒ Object

This will return the “top level section” for a page, which is the section directly below the root (a.k.a My Site) that this page is in. If this page is in root, then this will return root.



262
263
264
265
 
# File 'app/models/page.rb', line 262

def top_level_section
  a = ancestors
  (a.size > 0 && ancestors[1]) ? ancestors[1] : Section.root.first
end