nate-browsercms 3.0.210

data/app/models/page.rb

@@ -0,0 +1,293 @@
+class Page < ActiveRecord::Base
+  
+  is_archivable
+  flush_cache_on_change
+  is_hideable
+  is_publishable
+  uses_soft_delete
+  is_userstamped
+  is_versioned
+  
+  has_many :connectors, :order => "connectors.container, connectors.position"
+  has_many :page_routes
+  
+  named_scope :named, lambda{|name| {:conditions => ['pages.name = ?', name]}}
+  named_scope :with_path, lambda{|path| {:conditions => ['pages.path = ?', path]}}
+  
+  # This scope will accept a connectable object or a Hash.  The Hash is expect to have
+  # a value for the key :connectable, which is the connectable object, and possibly
+  # a value for the key :version.  The Hash contains a versioned connectable object,
+  # it will use the value in :version if present, otherwise it will use the version 
+  # of the object.  In either case of a connectable object or a Hash, if the object
+  # is not versioned, no version will be used
+  named_scope :connected_to, lambda { |b| 
+    if b.is_a?(Hash)
+      obj = b[:connectable]
+      if obj.class.versioned?
+        ver = b[:version] ? b[:version] : obj.version
+      else
+        ver = nil
+      end
+    else
+      obj = b
+      ver = obj.class.versioned? ? obj.version : nil
+    end
+    
+    if ver
+      { :include => :connectors, 
+        :conditions => ['connectors.connectable_id = ? and connectors.connectable_type = ? and connectors.connectable_version = ?', obj.id, obj.class.base_class.name, ver] }
+    else
+      { :include => :connectors, 
+        :conditions => ['connectors.connectable_id = ? and connectors.connectable_type = ?', obj.id, obj.class.base_class.name] }    
+    end 
+  }  
+  
+  has_one :section_node, :as => :node
+  
+  has_many :tasks
+  
+  before_validation :append_leading_slash_to_path
+  before_destroy :delete_connectors
+  
+  validates_presence_of :name, :path
+  validate :path_unique?
+  validate :path_not_reserved
+          
+  def after_build_new_version(new_version)
+    copy_connectors
+    true
+  end  
+  
+  def copy_connectors
+    copy_from_version = @copy_connectors_from_version ? @copy_connectors_from_version : version - 1
+    
+    connectors.for_page_version(copy_from_version).all(:order => "connectors.container, connectors.position").each do |c|
+      if c.connectable #The connector won't have a connectable if it has been deleted
+        connectable = c.connectable_type.constantize.versioned? ? c.connectable.as_of_version(c.connectable_version) : c.connectable
+      
+        #If are publishing this page, We need to publish the other page if it is not already published
+        if published? && c.connectable_type.constantize.publishable? && !c.connectable.published?
+          connectable.publish_by_page!(self)
+        end      
+      
+        #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 @copy_connectors_from_version && connectable.class.versioned? && !connectable.current_version?
+          connectable = connectable.class.find(connectable.id)
+          connectable.published_by_page = self if connectable.class.publishable?
+          connectable.revert_to(c.connectable_version)
+        end
+      
+        connectors.build(
+          :page_version => version, 
+          :connectable => connectable, 
+          :connectable_version => connectable.class.versioned? ? connectable.version : nil,         
+          :container => c.container, 
+          :position => c.position
+        )
+      end
+    end
+    
+    @copy_connectors_from_version = nil    
+    true
+  end  
+    
+  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)))
+      Connector.create(
+        :page => self,
+        :page_version => version,
+        :connectable => connectable,
+        :connectable_version => connectable.class.versioned? ? connectable.version : nil, 
+        :container => container)      
+    end
+  end  
+  
+  %w(up down to_top to_bottom).each do |d|
+    define_method("move_connector_#{d}") do |connector|
+      move_connector(connector, d)
+    end
+  end
+
+  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(version).like(connector).first.send("move_#{direction}")
+    end    
+  end  
+  
+  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(version).like(connector).first
+        new_connector.destroy
+      else
+        raise "Error occurred while trying to remove connector #{connector.id}"
+      end
+    end
+  end          
+          
+  def delete_connectors
+    connectors.for_page_version(version).all.each{|c| c.destroy }
+  end        
+         
+  #This is done to let copy_connectors know which version to pull from
+  #copy_connectors will get called later as an after_update callback
+  alias_method :original_revert_to, :revert_to
+  def revert_to(version)
+    @copy_connectors_from_version = version
+    original_revert_to(version)
+  end         
+          
+  def file_size
+    "?"
+  end
+  
+  def section_id
+    section ? section.id : nil
+  end
+  
+  def section
+    section_node ? section_node.section : nil
+  end
+  
+  def section_id=(sec_id)
+    self.section = Section.find(sec_id)
+  end
+  
+  def section=(sec)
+    if section_node
+      section_node.move_to_end(sec)
+    else
+      build_section_node(:node => self, :section => sec)
+    end      
+  end
+  
+  def public?
+    section ? section.public? : false
+  end
+  
+  def page_title
+    title.blank? ? name : title
+  end
+  
+  %w(up down to_top to_bottom).each do |d|
+    define_method("move_connector_#{d}") do |connector|
+      move_connector(connector, d)
+    end
+  end
+    
+  def append_leading_slash_to_path
+    if path.blank?
+      self.path = "/"
+    elsif path[0,1] != "/"
+      self.path = "/#{path}"
+    end
+  end
+  
+  def path_unique?
+    conditions = ["path = ?", path]
+    unless new_record?
+      conditions.first << " and id != ?"
+      conditions << id
+    end
+    if self.class.count(:conditions => conditions) > 0
+      errors.add(:path, "must be unique")
+    end
+  end   
+  
+  def path_not_reserved
+    if Cms.reserved_paths.include?(path)
+      errors.add(:path, "is invalid, '#{path}' a reserved path")
+    end
+  end
+      
+  def layout
+    template_file_name && "templates/#{template_file_name.split('.').first}"
+  end
+  
+  # This will be nil if it is a file system based template
+  def template
+    PageTemplate.find_by_file_name(template_file_name)
+  end
+  
+  def template_name
+    template_file_name && PageTemplate.display_name(template_file_name)
+  end
+
+  def ancestors
+    section_node.ancestors
+  end
+  
+  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
+    
+  #Returns true if the block attached to each connector in the given container are published
+  def container_published?(container)
+    connectors.for_page_version(version).in_container(container.to_s).all? do |c| 
+      c.connectable_type.constantize.publishable? ? c.connectable.published? : true
+    end
+  end
+  
+  # Returns the number of connectables in the given container for this version of this page
+  def connectable_count_for_container(container)
+    connectors.for_page_version(version).in_container(container.to_s).count
+  end
+    
+  def self.find_live_by_path(path)
+    page_versions = Page::Version.all(:conditions => {
+        :path => path, 
+        :archived => false, 
+        :published => true}, 
+        :order => "version desc")
+    for page_version in page_versions
+      next if page_version.page.nil? #skip versions that belong to deleted pages
+      page = page_version.page.as_of_version(page_version.version)
+      return page.live_version? ? page : nil
+    end
+    nil
+  end
+  
+  def name_with_section_path
+    a = ancestors
+    (a[1..a.size].map{|a| a.name} + [name]).join(" / ")
+  end
+  
+  # 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.
+  def top_level_section
+    a = ancestors
+    (a.size > 0 && ancestors[1]) ? ancestors[1] : Section.root.first
+  end
+  
+  def current_task
+    tasks.incomplete.first
+  end
+  
+  def assigned_to
+    current_task ? current_task.assigned_to : nil
+  end
+  
+  def assigned_to?(user)
+    assigned_to == user
+  end
+  
+end
+

data/app/models/page_partial.rb

@@ -0,0 +1,22 @@
+class PagePartial < DynamicView
+  
+  before_validation :prepend_underscore
+  
+  validates_format_of :name, :with => /\A_[a-z]+[a-z0-9_]*\Z/, :message => "can only contain lowercase letters, numbers and underscores and must begin with an underscore"  
+  
+  def file_path
+    File.join(self.class.base_path, "partials", file_name)
+  end  
+  
+  def self.display_name(file_name)
+    name, format, handler = file_name.split('.')
+    "#{name.sub(/^_/,'').titleize} (#{format}/#{handler})"
+  end  
+  
+  def prepend_underscore
+    if !name.blank? && name[0,1] != '_'
+      self.name = "_#{name}"
+    end
+  end
+  
+end

data/app/models/page_route.rb

@@ -0,0 +1,58 @@
+class PageRoute < ActiveRecord::Base
+  belongs_to :page
+  has_many :conditions, :class_name => "PageRouteCondition"
+  has_many :requirements, :class_name => "PageRouteRequirement"
+  
+  validates_presence_of :pattern, :page_id
+  validates_uniqueness_of :pattern
+
+  after_save :reload_routes
+
+  def reload_routes
+    ActionController::Routing::Routes.load!
+  end
+
+  def add_condition(name, value)
+    conditions.build(:name => name.to_s, :value => value.to_s)
+  end  
+  
+  def add_requirement(name, value)
+    requirements.build(:name => name.to_s, :value => value.to_s)
+  end
+  
+  def conditions_map
+    conditions.inject({}){|acc, e| acc[e.name.to_sym] = e.value.to_sym; acc}
+  end
+  
+  def requirements_map
+    requirements.inject({}){|acc, e| acc[e.name.to_sym] = Regexp.new(e.value); acc}
+  end
+  
+  def route_name
+    name ? name.to_slug.gsub('-','_') : nil
+  end
+  
+  # This is used in defining the route in the ActionController::Routing
+  def options_map
+    m = {:controller => "cms/content", :action => "show_page_route"}
+    
+    m[:_page_route_id] = self.id.to_s
+    
+    m[:requirements] = requirements_map
+    m[:conditions] = conditions_map
+    
+    m
+  end
+  
+  # This is called by an instance of the content controller 
+  # in the process of rendering a page.  This will eval the code
+  # stored in this page route in the context of the controller.  
+  # The main purpose of this method is to set instance variables 
+  # that will be used by one or more portlets when the page is rendered.  
+  # To set an instance variable, the code should contain something like:
+  #    @news_article = NewsArticle.find(params[:id]))
+  def execute(controller)
+    controller.instance_eval(code) unless code.blank?
+  end
+  
+end

data/app/models/page_route_condition.rb

@@ -0,0 +1,2 @@
+class PageRouteCondition < PageRouteOption
+end

data/app/models/page_route_option.rb

@@ -0,0 +1,3 @@
+class PageRouteOption < ActiveRecord::Base
+  belongs_to :page_route
+end

data/app/models/page_route_requirement.rb

@@ -0,0 +1,2 @@
+class PageRouteRequirement < PageRouteOption
+end

data/app/models/page_template.rb

@@ -0,0 +1,48 @@
+class PageTemplate < DynamicView
+
+  validates_format_of :name, :with => /\A[a-z]+[a-z0-9_]*\Z/, :message => "can only contain lowercase letters, numbers and underscores and must begin with a lowercase letter"
+
+  def file_path
+    File.join(self.class.file_path, file_name)
+  end
+  
+  def self.relative_path
+    File.join("layouts", "templates")
+  end
+  
+  def self.file_path
+    File.join(base_path, relative_path)
+  end
+  
+  def self.default_body
+    html = <<HTML
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
+    <title><%= page_title %></title>
+    <%= yield :html_head %>
+  </head>
+  <body>
+    <%= cms_toolbar %>
+    <%= container :main %>
+  </body>
+</html>
+HTML
+    html
+  end
+  
+  def self.display_name(file_name)
+    name, format, handler = file_name.split('.')
+    "#{name.titleize} (#{format}/#{handler})"
+  end
+  
+  # This is a combination of file system page templates 
+  # and database page templates
+  def self.options
+    file_system_templates = ActionController::Base.view_paths.map{|p| Dir["#{p}/#{relative_path}/*"]}.flatten.map{|f| File.basename(f)}
+    page_templates = file_system_templates + all.map{|t| t.file_name }
+    page_templates.map{|f| [display_name(f), f] }.sort.uniq
+  end
+  
+end

data/app/models/permission.rb

@@ -0,0 +1,10 @@
+class Permission < ActiveRecord::Base
+  has_many :group_permissions
+  has_many :groups, :through => :group_permissions
+  
+  validates_presence_of :name
+  validates_uniqueness_of :name
+  
+  named_scope :named, lambda{|name| {:conditions => {:name => name}}}
+  
+end

data/app/models/portlet.rb

@@ -0,0 +1,108 @@
+class Portlet < ActiveRecord::Base
+
+  validates_presence_of :name
+
+  #These are here simply to temporarily hold these values
+  #Makes it easy to pass them through the process of selecting a portlet type
+  attr_accessor :connect_to_page_id, :connect_to_container
+  
+  def self.inherited(subclass)
+    super if defined? super
+  ensure
+    ( @subclasses ||= [] ).push(subclass).uniq!
+    subclass.class_eval do
+      
+      has_dynamic_attributes
+      
+      acts_as_content_block(
+        :versioned => false, 
+        :publishable => false,
+        :renderable => {:instance_variable_name_for_view => "@portlet"})
+      
+      def self.helper_path
+        "app/portlets/helpers/#{name.underscore}_helper.rb"
+      end
+
+      def self.helper_class
+        "#{name}Helper".constantize
+      end      
+    end      
+  end
+
+  # In Rails, Classes aren't loaded until you ask for them
+  # This method will load all portlets that are defined
+  # in a app/portlets directory on the load path
+  def self.load_portlets
+    ActiveSupport::Dependencies.load_paths.each do |d| 
+      if d =~ /app\/portlets/
+        Dir["#{d}/*_portlet.rb"].each{|p| require_dependency(p) }
+      end
+    end
+  end
+
+  def self.has_edit_link?
+    false
+  end
+  
+  def self.types
+    load_portlets
+    @subclasses || []
+  end
+
+  def self.get_subclass(type)
+    raise "Unknown Portlet Type" unless types.map(&:name).include?(type)
+    type.constantize 
+  end
+
+  def self.content_block_type
+    "portlet"
+  end 
+  
+  def self.content_block_type_for_list
+    "portlet"
+  end
+  
+  # For column in list
+  def portlet_type_name
+    type.titleize
+  end
+
+  def self.form
+    "portlets/#{name.tableize.sub('_portlets','')}/form"
+  end
+  
+  def self.default_template
+    template_file = ActionController::Base.view_paths.map do |vp| 
+      path = vp.to_s.first == "/" ? vp.to_s : File.join(Rails.root, vp.to_s)
+      File.join(path, default_template_path)
+    end.detect{|f| File.exists? f }
+    template_file ? open(template_file){|f| f.read } : ""
+  end
+  
+  def self.set_default_template_path(s)
+    @default_template_path = s
+  end
+  
+  def self.default_template_path
+    @default_template_path ||= "portlets/#{name.tableize.sub('_portlets','')}/render.html.erb"
+  end
+
+  def inline_options
+    {:inline => self.template}
+  end
+
+  def type_name
+    type.to_s.titleize
+  end
+
+  def self.columns_for_index
+    [ {:label => "Name", :method => :name, :order => "name" },
+      {:label => "Type", :method => :type_name, :order => "type" },
+      {:label => "Updated On", :method => :updated_on_string, :order => "updated_at"} ]
+  end
+  
+  def instance_name
+    "#{self.class.name.demodulize.underscore}_#{id}"
+  end
+  
+end

data/app/models/redirect.rb

@@ -0,0 +1,4 @@
+class Redirect < ActiveRecord::Base
+  validates_presence_of :from_path, :to_path
+  validates_uniqueness_of :from_path
+end

data/app/models/section.rb

@@ -0,0 +1,140 @@
+class Section < ActiveRecord::Base
+
+  flush_cache_on_change
+  
+  #The node that links this section to its parent
+  has_one :node, :class_name => "SectionNode", :as => :node
+  
+  #The nodes that link this section to its children
+  has_many :child_nodes, :class_name => "SectionNode"
+  has_many :child_sections, :class_name => "SectionNode", :conditions => ["node_type = ?", "Section"], :order => 'section_nodes.position'
+
+  has_many :pages, :through => :child_nodes, :source => :node, :source_type => 'Page', :order => 'section_nodes.position'
+  has_many :sections, :through => :child_nodes, :source => :node, :source_type => 'Section', :order => 'section_nodes.position'
+
+  has_many :group_sections
+  has_many :groups, :through => :group_sections
+  
+  named_scope :root, :conditions => ['root = ?', true]
+  named_scope :system, :conditions => {:name => 'system'}
+  
+  named_scope :hidden, :conditions => {:hidden => true}
+  named_scope :not_hidden, :conditions => {:hidden => false}
+  
+  named_scope :named, lambda{|name| {:conditions => ['sections.name = ?', name]}}
+  named_scope :with_path, lambda{|path| {:conditions => ['sections.path = ?', path]}}
+  
+  validates_presence_of :name, :path
+  #validates_presence_of :parent_id, :if => Proc.new {root.count > 0}, :message => "section is required"
+  
+  # Disabling '/' in section name for interoperability with FCKEditor file browser
+  validates_format_of :name, :with => /\A[^\/]*\Z/, :message => "cannot contain '/'"
+  
+  validate :path_not_reserved
+  
+  before_destroy :deletable?
+  
+  attr_accessor :full_path
+  
+  def visible_child_nodes
+    children = child_nodes.of_type(["Section", "Page", "Link"]).all(:order => 'section_nodes.position')
+    children.select{|sn| sn.visible?}
+  end
+  
+  def all_children_with_name
+    child_sections.map do |s|
+      if s.node
+        s.node.full_path = root? ? s.node.name : "#{name} / #{s.node.name}"
+        [s.node] << s.node.all_children_with_name
+      end
+    end.flatten.compact
+  end
+  
+  def parent_id
+    parent ? parent.id : nil
+  end
+  
+  def parent
+    node ? node.section : nil
+  end
+  
+  def parent_id=(sec_id)
+    self.parent = Section.find(sec_id)
+  end
+  
+  def parent=(sec)
+    if node
+      node.move_to_end(sec)
+    else
+      build_node(:node => self, :section => sec)
+    end      
+  end  
+  
+  def ancestors
+    node ? node.ancestors : []
+  end
+  
+  def move_to(section)
+    if root?
+      false
+    else
+      node.move_to_end(section)
+    end
+  end
+  
+  def public?
+    !!(groups.find_by_code('guest'))
+  end
+  
+  def empty?
+    child_nodes.reject{|n| n.orphaned?}.empty?
+  end
+  
+  def deletable?
+    !root? && empty?
+  end
+  
+  def editable_by_group?(group)
+    group.editable_by_section(self)
+  end
+  
+  def status
+    public? ? :unlocked : :locked
+  end
+  
+  def self.find_by_name_path(name_path)
+    section = Section.root.first
+    children = name_path.split("/")[1..-1] || []
+    children.each do |name|
+      section = section.sections.first(:conditions => {:name => name})
+    end
+    section
+  end
+  
+  #The first page that is a decendent of this section
+  def first_page_or_link
+    section_node = child_nodes.of_type(['Link','Page']).first 
+    return section_node.node if section_node
+    sections.each do |s| 
+      node = s.first_page_or_link
+      return node if node
+    end
+    nil
+  end
+    
+  def actual_path
+    if root?
+      "/"
+    else
+      p = first_page_or_link
+      p ? p.path : "#"
+    end
+  end  
+  
+  def path_not_reserved
+    if Cms.reserved_paths.include?(path)
+      errors.add(:path, "is invalid, '#{path}' a reserved path")
+    end
+  end
+      
+end