browsercms 3.5.7 → 4.0.0.alpha

data/app/models/cms/file_block.rb

@@ -2,6 +2,7 @@ module Cms
   class FileBlock < Cms::AbstractFileBlock
 
     acts_as_content_block :taggable => true
+    content_module :core
 
     has_attachment :file
     validates_attachment_presence :file, :message => "You must upload a file"

data/app/models/cms/form.rb

@@ -0,0 +1,47 @@
+module Cms
+  class Form < ActiveRecord::Base
+    acts_as_content_block
+    content_module :forms
+    is_addressable path: '/forms', template: 'default'
+
+    has_many :fields,  -> {order(:position)}, class_name: 'Cms::FormField'
+    has_many :entries, class_name: 'Cms::FormEntry'
+
+    validates_format_of :notification_email, :with => /@/, unless: lambda { |form| form.notification_email.blank? }
+
+    # Copy any field related errors into the model :base so they get displayed at the top of the form.
+    after_validation do
+      unless errors[:fields].empty?
+        fields.each do |field|
+          field.errors.each do |attribute, error|
+            errors[:base] << field.errors.full_message(attribute, error)
+          end
+
+        end
+      end
+    end
+
+    def field(name)
+      fields.select {|f| f.name == name}.first
+    end
+
+    def required?(name)
+      field = field(name)
+      field ? field.required? : false
+    end
+
+    def field_names
+      fields.collect { |f| f.name }
+    end
+
+    def show_text?
+      confirmation_behavior.to_sym == :show_text
+    end
+
+    # Provides a sample Entry for the form.
+    # This allows us to use SimpleForm to layout out elements but ignore the input when the form submits.
+    def new_entry
+      Cms::Entry.new(form: self)
+    end
+  end
+end

data/app/models/cms/form_entry.rb

@@ -0,0 +1,71 @@
+module Cms
+  class FormEntry < ActiveRecord::Base
+
+    store :data_columns
+    belongs_to :form, class_name: 'Cms::Form'
+
+    after_initialize :add_field_accessors
+
+    def permitted_params
+      form.field_names
+    end
+
+    # Returns a copy of the persisted object. This is required so that existing records fetched from the db can
+    # have validation during update operations.
+    #
+    # @return [Cms::FormEntry] A copy of this record with validations enabled on it.
+    def enable_validations
+      entry = FormEntry.for(form)
+      entry.attributes = self.attributes
+      entry.instance_variable_set(:@new_record, false)
+      entry
+    end
+
+    class << self
+
+      # Create an Entry for a specific Form. It will have validation and accessors based on the fields of the form.
+      #
+      # @param [Cms::Form] form
+      def for(form)
+        entry = FormEntry.ish(form: form) {
+          form.field_names.each do |field_name|
+            if form.required?(field_name)
+              validates field_name, presence: true
+            end
+          end
+        }
+        entry
+      end
+
+      # Create an instance of a FormEntry with the given methods.
+      def ish(*args, &block)
+        dup(&block).new(*args)
+      end
+
+      # Creates a faux class with singleton methods. Solves this problem:
+      #   https://github.com/rails/rails/issues/5449
+      def dup(&block)
+        super.tap do |dup|
+          def dup.name()
+            FormEntry.name
+          end
+
+          dup.class_eval(&block) if block
+        end
+      end
+    end
+    private
+
+    # Add a single field accessor to the current instance of the object. (I.e. not shared with others)
+    def add_store_accessor(field_name)
+      singleton_class.class_eval { store_accessor :data_columns, field_name }
+    end
+
+    def add_field_accessors
+      return unless form
+      form.field_names.each do |field_name|
+        add_store_accessor(field_name)
+      end
+    end
+  end
+end

data/app/models/cms/form_field.rb

@@ -0,0 +1,78 @@
+module Cms
+  class FormField < ActiveRecord::Base
+    extend DefaultAccessible
+
+    belongs_to :form
+    acts_as_list scope: :form
+
+    attr_accessor :edit_path, :delete_path
+
+    # Name is assigned when the Field is created, and should not be changed afterwords.
+    # Otherwise existing entries will not display their data correctly.
+    #
+    # FormField#name is used for input fields. I.e. <%= f.input field.name %>
+    before_validation(on: :create) do
+      self.name = label.parameterize.underscore.to_sym if label
+    end
+
+    validates :name, :uniqueness => {:scope => :form_id, message: "can only be used once per form."}
+
+    def as_json(options={})
+      super(:methods => [:edit_path, :delete_path])
+    end
+
+
+    # Return the form widget that should be used to render this field.
+    #
+    # @return [Symbol] A SimpleForm input mapping (i.e. :string, :text)
+    def as
+      case field_type
+        when "text_field"
+          :string
+        when "text_area"
+          :text
+        else
+          field_type.to_sym
+      end
+    end
+
+    # Return options to be passed to a SimpleForm input.
+    # @return [Hash]
+    # @param [Hash] config
+    # @option config [Boolean] :disabled If the field should be disabled.
+    # @option config [FormEntry] :entry
+    def options(config={})
+      opts = {label: label}
+      if field_type != "text_field"
+        opts[:as] = self.as
+      end
+      if config[:disabled]
+        opts[:disabled] = true
+        opts[:readonly] = 'readonly'
+      end
+      opts[:required] = !!required
+      opts[:hint] = instructions if instructions
+      unless choices.blank?
+        opts[:collection] = parse_choices
+        opts[:prompt] = !self.required?
+      end
+      unless config[:entry] && config[:entry].send(name)
+        opts[:input_html] =  {value: default_value}
+      end
+      opts
+    end
+
+
+    # Don't allow name to be set via UI.
+    def self.permitted_params
+      super - [:name]
+    end
+
+    private
+
+    # Choices is a single text area where choices are divided by endlines.
+    def parse_choices
+      choices.split( /\r?\n/ )
+    end
+  end
+end

data/app/models/cms/group.rb

@@ -3,10 +3,10 @@
 # their permissions from all groups combined represents what they can do.
 #
 class Cms::Group < ActiveRecord::Base
- GUEST_CODE = "guest"
+  GUEST_CODE = "guest"
 
   has_many :user_group_memberships, :class_name => 'Cms::UserGroupMembership'
-  has_many :users, :through => :user_group_memberships, :class_name => 'Cms::User'
+  has_many :users, :through => :user_group_memberships, :class_name => 'Cms::PersistentUser'
 
   has_many :group_permissions, :class_name => 'Cms::GroupPermission'
   has_many :permissions, :through => :group_permissions, :class_name => 'Cms::Permission'
@@ -16,18 +16,28 @@ class Cms::Group < ActiveRecord::Base
 
   belongs_to :group_type, :class_name => 'Cms::GroupType'
 
-  # :group_type might be a bad idea, but only Admins should be modifying groups anyway
-  attr_accessible :name, :code, :group_type, :permission_ids, :section_ids
-  include Cms::DefaultAccessible
+  extend Cms::DefaultAccessible
+
+  # @override Add extra params
+  def self.permitted_params
+    super + [:group_type_id] +[section_ids: [], permission_ids: []]
+  end
+
 
   validates_presence_of :name
 
-  scope :named, lambda { |n| {:conditions => {:name => n}} }
-  scope :with_code, lambda { |c| {:conditions => {:code => c}} }
+  class << self
+    def named(n)
+      where name: n
+    end
 
+    def with_code(c)
+      where code: c
+    end
+  end
 
-  scope :public, :include => :group_type, :conditions => ["#{Cms::GroupType.table_name}.cms_access = ?", false]
-  scope :cms_access, :include => :group_type, :conditions => ["#{Cms::GroupType.table_name}.cms_access = ?", true]
+  scope :public, -> { where(["#{Cms::GroupType.table_name}.cms_access = ?", false]).includes(:group_type).references(:group_type) }
+  scope :cms_access, -> { where(["#{Cms::GroupType.table_name}.cms_access = ?", true]).includes(:group_type).references(:group_type) }
 
   def guest?
     group_type && group_type.guest?

data/app/models/cms/group_permission.rb

@@ -1,7 +1,7 @@
 module Cms
   class GroupPermission < ActiveRecord::Base
 
-    include DefaultAccessible
+    extend DefaultAccessible
 
     belongs_to :group, :class_name => 'Cms::Group'
     belongs_to :permission, :class_name => 'Cms::Permission'

data/app/models/cms/group_section.rb

@@ -1,7 +1,7 @@
 module Cms
   class GroupSection < ActiveRecord::Base
 
-    include DefaultAccessible
+    extend DefaultAccessible
 
     belongs_to :group, :class_name => 'Cms::Group'
     belongs_to :section, :class_name => 'Cms::Section'

data/app/models/cms/group_type.rb

@@ -1,16 +1,16 @@
 module Cms
   class GroupType < ActiveRecord::Base
-    attr_accessible :name, :guest, :cms_access
+   #attr_accessible :name, :guest, :cms_access
 
     has_many :groups, :class_name => 'Cms::Group'
     has_many :group_type_permissions, :class_name => 'Cms::GroupTypePermission'
     has_many :permissions, :through => :group_type_permissions, :class_name => 'Cms::Permission'
 
-    scope :guest, :conditions => ["#{GroupType.table_name}.guest = ?", true]
-    scope :non_guest, :conditions => ["#{GroupType.table_name}.guest = ?", false]
+    scope :guest, -> {where( ["#{GroupType.table_name}.guest = ?", true])}
+    scope :non_guest, -> {where( ["#{GroupType.table_name}.guest = ?", false])}
 
-    scope :cms_access, :conditions => ["#{GroupType.table_name}.cms_access = ?", true]
-    scope :non_cms_access, :conditions => ["#{GroupType.table_name}.cms_access = ?", false]
+    scope :cms_access, -> {where( ["#{GroupType.table_name}.cms_access = ?", true])}
+    scope :non_cms_access, -> {where( ["#{GroupType.table_name}.cms_access = ?", false])}
 
   end
 end

data/app/models/cms/group_type_permission.rb

@@ -3,6 +3,6 @@ module Cms
     belongs_to :group_type, :class_name => 'Cms::GroupType'
     belongs_to :permission, :class_name => 'Cms::Permission'
 
-    include DefaultAccessible
+    extend DefaultAccessible
   end
 end

data/app/models/cms/html_block.rb

@@ -2,34 +2,29 @@ module Cms
   class HtmlBlock < ActiveRecord::Base
 
     acts_as_content_block :taggable => true
+    content_module :core
 
     # This shouldn't be necessary but it is for browsercms.seeds.rb'
-    attr_accessible :name, :content
+   #attr_accessible :name, :content
 
     validates_presence_of :name
 
+    def self.eager_matching(term)
+      "%#{term}%"
+    end
     # Override of search scope from searching behavior to deal with include_body
-    scope :search, lambda { |search_params|
+    def self.search(search_params)
       term = search_params.is_a?(Hash) ? search_params[:term] : search_params
       include_body = search_params.is_a?(Hash) ? search_params[:include_body] : false
-      conditions = []
-      columns = ["name"]
-      columns << "content" if include_body
-      unless term.blank?
-        columns.each do |c|
-          if conditions.empty?
-            conditions = ["lower(#{table_name}.#{c}) like lower(?)"]
-          else
-            conditions.first << "or lower(#{table_name}.#{c}) like (?)"
-          end
-          conditions << "%#{term}%"
-        end
-        conditions[0] = "(#{conditions[0]})"
+
+
+      conditions = ["name like lower(?)", eager_matching(term)]
+      if include_body
+        conditions[0] << "OR content like lower(?)"
+        conditions << eager_matching(term)
       end
-      scope = {}
-      scope[:conditions] = conditions if conditions
-      scope
-    }
+      where(conditions)
+    end
 
     def self.display_name
       "Text"

data/app/models/cms/image_block.rb

@@ -2,6 +2,7 @@ module Cms
   class ImageBlock < Cms::AbstractFileBlock
 
     acts_as_content_block :taggable => true
+    content_module :core
     has_attachment :file, :styles => {:thumb => "80x80"}
     validates_attachment_presence :file, :message => "You must upload a file"
 

data/app/models/cms/link.rb

@@ -1,18 +1,20 @@
 class Cms::Link < ActiveRecord::Base
-  acts_as_content_block :connectable => false
+  acts_as_content_block connectable: false, content_module: false
 
-  scope :named, lambda{|name| {:conditions => ["#{table_name}.name = ?", name]}}
-  
-  has_one :section_node, :as => :node, :dependent => :destroy, :inverse_of => :node, :class_name => 'Cms::SectionNode'
+  scope :named, lambda { |name| {:conditions => ["#{table_name}.name = ?", name]} }
 
   validates_presence_of :name
 
-  include Cms::Addressable
-  include Cms::Addressable::DeprecatedPageAccessors
+  is_addressable
+  include Cms::Concerns::Addressable::DeprecatedPageAccessors
 
   #needed by menu_helper
   def path
     url
   end
 
+  # @override
+  def self.permitted_params
+    super + [:publish_on_save]
+  end
 end

data/app/models/cms/page.rb

@@ -12,45 +12,55 @@ class Cms::Page < ActiveRecord::Base
   is_userstamped
   is_versioned
 
-  has_many :connectors, :class_name => 'Cms::Connector', :order => "#{Cms::Connector.table_name}.container, #{Cms::Connector.table_name}.position"
+  has_many :connectors, -> { order("#{Cms::Connector.table_name}.container, #{Cms::Connector.table_name}.position") }, :class_name => 'Cms::Connector'
   has_many :page_routes, :class_name => 'Cms::PageRoute'
   has_many :tasks
 
-  include Cms::DefaultAccessible
-  attr_accessible :name, :path, :template_file_name, :hidden, :cacheable # Needs to be explicit so seed data will work.
-
-  scope :named, lambda { |name| {:conditions => ["#{table_name}.name = ?", name]} }
-  scope :with_path, lambda { |path| {:conditions => ["#{table_name}.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
-  scope :connected_to, lambda { |b|
-    if b.is_a?(Hash)
-      obj = b[:connectable]
-      if obj.class.versioned?
-        ver = b[:version] ? b[:version] : obj.version
+  extend Cms::DefaultAccessible
+
+  class << self
+    def named(name)
+      where(["#{table_name}.name = ?", name])
+    end
+
+    def with_path(path)
+      where(["#{table_name}.path = ?", path])
+    end
+
+    # 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
+    def connected_to(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
-        ver = nil
+        obj = b
+        ver = obj.class.versioned? ? obj.version : nil
       end
-    else
-      obj = b
-      ver = obj.class.versioned? ? obj.version : nil
-    end
 
-    if ver
-      {:include => :connectors,
-       :conditions => ["#{Cms::Connector.table_name}.connectable_id = ? and #{Cms::Connector.table_name}.connectable_type = ? and #{Cms::Connector.table_name}.connectable_version = ?", obj.id, obj.class.base_class.name, ver]}
-    else
-      {:include => :connectors,
-       :conditions => ["#{Cms::Connector.table_name}.connectable_id = ? and #{Cms::Connector.table_name}.connectable_type = ?", obj.id, obj.class.base_class.name]}
+      if ver
+        query = where(["#{Cms::Connector.table_name}.connectable_id = ? and #{Cms::Connector.table_name}.connectable_type = ? and #{Cms::Connector.table_name}.connectable_version = ?", obj.id, obj.class.base_class.name, ver])
+      else
+        query = where(["#{Cms::Connector.table_name}.connectable_id = ? and #{Cms::Connector.table_name}.connectable_type = ?", obj.id, obj.class.base_class.name])
+      end
+      query.includes(:connectors).references(:connectors)
+
     end
-  }
 
-  # currently_connected_to tightens the scope of connected_to by restricting to the 
+    # @override
+    def permitted_params
+      super + [:visibility, :publish_on_save]
+    end
+  end
+  # currently_connected_to tightens the scope of connected_to by restricting to the
   # results to matches on current versions of pages only.  This renders obj versions
   # useless, as the older objects will very likely have older versions of pages and
   # thus return no results.
@@ -59,19 +69,14 @@ class Cms::Page < ActiveRecord::Base
 
     ver = obj.class.versioned? ? obj.version : nil
     if ver
-      {:include => :connectors,
-       :conditions => ["#{connectors_table}.connectable_id = ? and #{connectors_table}.connectable_type = ? and #{connectors_table}.connectable_version = ? and #{connectors_table}.page_version = #{Cms::Page.table_name}.version", obj.id, obj.class.base_class.name, ver]}
+      where(["#{connectors_table}.connectable_id = ? and #{connectors_table}.connectable_type = ? and #{connectors_table}.connectable_version = ? and #{connectors_table}.page_version = #{Cms::Page.table_name}.version", obj.id, obj.class.base_class.name, ver]).includes(:connectors).references(:connectors)
     else
-      {:include => :connectors,
-       :conditions => ["#{connectors_table}.connectable_id = ? and #{connectors_table}.connectable_type = ? and #{connectors_table}.page_version = #{Cms::Page.table_name}.version", obj.id, obj.class.base_class.name]}
+      where(["#{connectors_table}.connectable_id = ? and #{connectors_table}.connectable_type = ? and #{connectors_table}.page_version = #{Cms::Page.table_name}.version", obj.id, obj.class.base_class.name]).includes(:connectors).references(:connectors)
     end
   }
 
-  has_one :section_node, :as => :node, :dependent => :destroy, :inverse_of => :node, :class_name => 'Cms::SectionNode'
-
-
-  include Cms::Addressable
-  include Cms::Addressable::DeprecatedPageAccessors
+  is_addressable(no_dynamic_path: true)
+  include Cms::Concerns::Addressable::DeprecatedPageAccessors
 
 
   before_validation :append_leading_slash_to_path, :remove_trailing_slash_from_path
@@ -80,9 +85,62 @@ class Cms::Page < ActiveRecord::Base
   validates_presence_of :name, :path
 
   # Paths must be unique among undeleted records
-  validates_uniqueness_of :path, :scope=>:deleted
+  validates_uniqueness_of :path, :scope => :deleted
   validate :path_not_reserved
 
+  # Find the latest draft of a given page.
+  #
+  # @param [Integer | String] id_or_path The id or path of the page
+  # @return [Cms::Page::Version] The version of the page as of the current Draft.
+  # @raises [Cms::Errors::ContentNotFound] if no record could be found.
+  def self.find_draft(id_or_path)
+    if id_or_path.is_a? String
+      current = self.with_path(id_or_path).first
+    else
+      current = self.find(id_or_path)
+    end
+    if current
+      current.as_of_draft_version
+    else
+      raise Cms::Errors::DraftNotFound
+    end
+  end
+
+  # Finds the live version of a Page.
+  # @param [String] path The relative path to the page
+  # @return [Cms::Page] The page if found
+  # @rais [Cms::Errors::ContentNotFound] If no published page was found with the given path.
+  def self.find_live(path)
+    result = find_live_by_path(path)
+    unless result
+      raise Cms::Errors::ContentNotFound
+    end
+    result
+  end
+
+  # Find live version of a page.
+  # @return [Cms::Page] Or nil if not found.
+  def self.find_live_by_path(path)
+    published.not_archived.where(path: path).first
+  end
+
+  # Returns all content for the current page, excluding any deleted ones.
+  # @return [Array<ContentBlock>]
+  def contents
+    current_connectors.map(&:connectable_with_deleted)
+  end
+
+  # Return a list of all connectors for the current version of the page.
+  # @param [Symbol] container The name of the container to match (Optional - Return all)
+  def current_connectors(container=nil)
+    @current_connectors ||= self.connectors.for_page_version(self.version)
+    if (container)
+      @current_connectors.select { |c| c.container.to_sym == container }
+    else
+      @current_connectors
+    end
+  end
+
   # Implements Versioning Callback.
   def after_build_new_version(new_version)
     copy_connectors(
@@ -96,7 +154,7 @@ class Cms::Page < ActiveRecord::Base
   # Publish all
   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|
+    self.connectors.for_page_version(self.version).order("position").to_a.each do |c|
       if c.connectable_type.constantize.publishable? && con = c.connectable
         con.publish
       end
@@ -108,7 +166,7 @@ class Cms::Page < ActiveRecord::Base
   def copy_connectors(options={})
     logger.debug { "Copying connectors from Page #{id} v#{options[:from_version_number]} to v#{options[:to_version_number]}." }
 
-    c_found = connectors.for_page_version(options[:from_version_number]).all(:order => "#{Cms::Connector.table_name}.container, #{Cms::Connector.table_name}.position")
+    c_found = connectors.for_page_version(options[:from_version_number]).order("#{Cms::Connector.table_name}.container, #{Cms::Connector.table_name}.position").to_a
     logger.debug { "Found connectors #{c_found}" }
     c_found.each do |c|
 
@@ -134,11 +192,11 @@ class Cms::Page < ActiveRecord::Base
         logger.debug "When copying block #{connectable.inspect} version is '#{version}'"
 
         new_connector = connectors.create(
-          :page_version => options[:to_version_number],
-          :connectable => connectable, 
-          :connectable_version => version,
-          :container => c.container,
-          :position => c.position
+            :page_version => options[:to_version_number],
+            :connectable => connectable,
+            :connectable_version => version,
+            :container => c.container,
+            :position => c.position
         )
         logger.debug { "Built new connector #{new_connector}." }
       end
@@ -147,18 +205,21 @@ class Cms::Page < ActiveRecord::Base
   end
 
   # Adds a Content block to this page.
+  #
   # @param [ContentBlock] connectable The content block to be added
   # @param [Symbol] container The container to add it in (default :main)
   def add_content(connectable, container=:main)
     transaction do
       raise "Connectable is nil" unless connectable
       raise "Container is required" if container.blank?
+      #should_publish =  published? &&
+      #              connectable.connected_page &&
+      #              (connectable.class.publishable? ? connectable.published? : true)
+      should_publish = false
       update_attributes(
           :version_comment => "#{connectable} was added to the '#{container}' container",
-          :publish_on_save => (
-          published? &&
-              connectable.connected_page &&
-              (connectable.class.publishable? ? connectable.published? : true)))
+          :publish_on_save => should_publish
+      )
       connectors.create(
           :page_version => draft.version,
           :connectable => connectable,
@@ -167,14 +228,16 @@ class Cms::Page < ActiveRecord::Base
     end
   end
 
+  # @deprecated
   alias_method :create_connector, :add_content
 
+  # Moves a specific connector up or down within its container for a page.
   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")
+      update_attributes(:version_comment => "#{connector.connectable} was moved #{orientation} the '#{connector.container}' container", :publish_on_save => false)
       connectors.for_page_version(draft.version).like(connector).first.send("move_#{direction}")
     end
   end
@@ -188,7 +251,7 @@ class Cms::Page < ActiveRecord::Base
   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")
+      update_attributes(version_comment: "#{connector.connectable} was removed from the '#{connector.container}' container", publish_on_save: false)
 
       #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
@@ -201,7 +264,7 @@ class Cms::Page < ActiveRecord::Base
 
   # Pages that get deleted should be 'disconnected' from any blocks they were associated with.
   def delete_connectors
-    connectors.for_page_version(version).all.each { |c| c.destroy }
+    connectors.for_page_version(version).to_a.each { |c| c.destroy }
   end
 
   #This is done to let copy_connectors know which version to pull from
@@ -216,6 +279,14 @@ class Cms::Page < ActiveRecord::Base
     "NA"
   end
 
+  # Whether or not this page is considered the 'landing' page for its parent section. These 'Overview' pages
+  # will have the same path as their parent.
+  #
+  # @return [Boolean]
+  def landing_page?
+    parent.path == path
+  end
+
   def public?
     section ? section.public? : false
   end
@@ -298,15 +369,16 @@ class Cms::Page < ActiveRecord::Base
     connectors.for_page_version(version).in_container(container.to_s).count
   end
 
-  def self.find_live_by_path(path)
-    published.not_archived.first(:conditions => {:path => path})
-  end
-
   def name_with_section_path
     a = ancestors
     (a[1..a.size].map { |a| a.name } + [name]).join(" / ")
   end
 
+  # @return [Boolean] true if this page is the home page of the site.
+  def home?
+    path == "/"
+  end
+
   # This will return the "top level section" for this 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.
@@ -331,4 +403,29 @@ class Cms::Page < ActiveRecord::Base
     assigned_to == user
   end
 
+  # Return a collection of the available visibility statuses this model will accept via #visibility=
+  def visibilities
+    [['Public', :public], ['Archived', :archived], ['Hidden' , :hidden]]
+  end
+
+  def visibility
+    if archived?
+      :archived
+    elsif hidden?
+      :hidden
+    else
+      :public
+    end
+  end
+
+  def visibility=(new_state)
+    self.archived = false
+    self.hidden = false
+    if new_state.to_sym == :archived
+      self.archived = true
+    elsif new_state.to_sym == :hidden
+      self.hidden = true
+    end
+  end
+
 end