browsercms 3.3.4 → 3.4.0.rc1

data/app/models/cms/content_type_group.rb

@@ -0,0 +1,13 @@
+module Cms
+  class ContentTypeGroup < ActiveRecord::Base
+    has_many :content_types, :order => "#{ContentType.table_name}.id", :class_name => 'Cms::ContentType'
+
+    has_many :types, :order=>"priority, name", :class_name => 'Cms::ContentType'
+
+    def self.menu_list
+      order(:id).all
+    end
+
+
+  end
+end

data/app/models/cms/dynamic_view.rb

@@ -0,0 +1,102 @@
+module Cms
+  class DynamicView < ActiveRecord::Base
+
+    after_save :write_file_to_disk
+    after_destroy :remove_file_from_disk
+
+    scope :with_file_name, lambda { |file_name|
+      conditions = {:name => nil, :format => nil, :handler => nil}
+      if file_name && (parts = file_name.split(".")).size == 3
+        conditions[:name] = parts[0]
+        conditions[:format] = parts[1]
+        conditions[:handler] = parts[2]
+      end
+      {:conditions => conditions}
+    }
+
+    def self.inherited(subclass)
+      super if defined? super
+    ensure
+      subclass.class_eval do
+        flush_cache_on_change
+        is_publishable
+        uses_soft_delete
+        is_userstamped
+        is_versioned
+
+        before_validation :set_publish_on_save
+
+        validates_presence_of :name, :format, :handler
+        validates_uniqueness_of :name, :scope => [:format, :handler],
+                                :message => "Must have a unique combination of name, format and handler"
+
+      end
+    end
+
+    def self.new_with_defaults(options={})
+      new({:format => "html", :handler => "erb", :body => default_body}.merge(options))
+    end
+
+    def self.find_by_file_name(file_name)
+      with_file_name(file_name).first
+    end
+
+    def self.base_path
+      File.join(Rails.root, "tmp", "views")
+    end
+
+    def self.form_name
+      ActiveModel::Naming.singular(self)
+    end
+
+    def file_name
+      "#{name}.#{format}.#{handler}"
+    end
+
+    def display_name
+      self.class.display_name(file_name)
+    end
+
+    def write_file_to_disk
+      if respond_to?(:file_path) && !file_path.blank?
+        FileUtils.mkpath(File.dirname(file_path))
+        open(file_path, 'w') { |f| f << body }
+      end
+    end
+
+    def self.write_all_to_disk!
+      all(:conditions => {:deleted => false}).each { |v| v.write_file_to_disk }
+    end
+
+    def remove_file_from_disk
+      if respond_to?(:file_path) && File.exists?(file_path)
+        File.delete(file_path)
+      end
+    end
+
+    def self.default_body
+      ""
+    end
+
+    def set_publish_on_save
+      self.publish_on_save = true
+    end
+
+    # Get the plural symbol for a particular resource.
+    # i.e. Cms::PageTemplate -> :page_templates
+    def self.resource_name
+      resource_collection_name.pluralize
+    end
+
+    # Default implementation
+    def self.resource_collection_name
+      model_name.underscore
+    end
+
+    # So that route lookup works for these resources.
+    # See PathHelper#cms_index_path_for
+    def self.engine
+      "cms"
+    end
+  end
+end

data/app/models/cms/email_message.rb

@@ -0,0 +1,31 @@
+module Cms
+  class EmailMessage < ActiveRecord::Base
+
+    scope :undelivered, :conditions => "delivered_at is null"
+    validates_presence_of :recipients
+    after_create :deliver_now
+
+    def delivered?
+      !!delivered_at
+    end
+
+    def self.deliver!
+      # Send all messages, 100 at a time
+      undelivered.all(:limit => 100).each do |m|
+        m.deliver!
+      end
+    end
+
+    #TODO: Take this out when we have an email queue processor
+    def deliver_now
+      deliver!
+    end
+
+    def deliver!
+      return false if delivered?
+      Cms::EmailMessageMailer.email_message(self).deliver
+      update_attributes(:delivered_at => Time.now)
+    end
+
+  end
+end

data/app/models/cms/email_message_mailer.rb

@@ -0,0 +1,12 @@
+module Cms
+  class EmailMessageMailer < ActionMailer::Base
+
+
+    def email_message(message)
+      email = {:to=>message.recipients, :from=>message.sender, :subject => message.subject, :body =>message.body}
+      email[:content_type]  = message.content_type if message.content_type
+      mail email
+    end
+
+  end
+end

data/app/models/cms/file_block.rb

@@ -0,0 +1,11 @@
+module Cms
+  class FileBlock < Cms::AbstractFileBlock
+
+    acts_as_content_block :belongs_to_attachment => true, :taggable => true
+
+    def self.display_name
+      "File"
+    end
+
+  end
+end

data/app/models/cms/forgot_password_mailer.rb

@@ -0,0 +1,14 @@
+module Cms
+  class ForgotPasswordMailer < ActionMailer::Base
+
+    def reset_password(link, email)
+      @subject = "Account Management"
+      @body[:url] = link
+      @recipients = email
+      @from = 'do_not_reply@domain.com'
+      @sent_on = Time.now
+      template "cms/forgot_password_mailer/reset_password"
+    end
+
+  end
+end

data/app/models/cms/group.rb

@@ -0,0 +1,49 @@
+#
+# A group represents a collection of permissions. Each User can be assigned to one or more groups, and the sum of
+# their permissions from all groups combined represents what they can do.
+#
+class Cms::Group < ActiveRecord::Base
+
+  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 :group_permissions, :class_name => 'Cms::GroupPermission'
+  has_many :permissions, :through => :group_permissions, :class_name => 'Cms::Permission'
+
+  has_many :group_sections, :class_name => 'Cms::GroupSection'
+  has_many :sections, :through => :group_sections, :class_name => 'Cms::Section'
+
+  belongs_to :group_type, :class_name => 'Cms::GroupType'
+
+  validates_presence_of :name
+
+  scope :named, lambda { |n| {:conditions => {:name => n}} }
+  scope :with_code, lambda { |c| {:conditions => {:code => c}} }
+
+
+  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]
+
+  def guest?
+    group_type && group_type.guest?
+  end
+
+  def cms_access?
+    group_type && group_type.cms_access?
+  end
+
+  # Finds the guest group, which is a special group that represents public non-logged in users.
+  def self.guest
+    with_code(GUEST_CODE).first
+  end
+
+
+  def has_permission?(permission)
+    permissions.any? do |p|
+      return true if permission.to_sym == p.name.to_sym
+    end
+    false
+  end
+end

data/app/models/cms/group_permission.rb

@@ -0,0 +1,10 @@
+module Cms
+  class GroupPermission < ActiveRecord::Base
+
+    belongs_to :group, :class_name => 'Cms::Group'
+    belongs_to :permission, :class_name => 'Cms::Permission'
+
+    validates_uniqueness_of :permission_id, :scope => :group_id
+
+  end
+end

data/app/models/cms/group_section.rb

@@ -0,0 +1,6 @@
+module Cms
+  class GroupSection < ActiveRecord::Base
+    belongs_to :group, :class_name => 'Cms::Group'
+    belongs_to :section, :class_name => 'Cms::Section'
+  end
+end

data/app/models/cms/group_type.rb

@@ -0,0 +1,14 @@
+module Cms
+  class GroupType < ActiveRecord::Base
+    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 :cms_access, :conditions => ["#{GroupType.table_name}.cms_access = ?", true]
+    scope :non_cms_access, :conditions => ["#{GroupType.table_name}.cms_access = ?", false]
+
+  end
+end

data/app/models/cms/group_type_permission.rb

@@ -0,0 +1,6 @@
+module Cms
+  class GroupTypePermission < ActiveRecord::Base
+    belongs_to :group_type, :class_name => 'Cms::GroupType'
+    belongs_to :permission, :class_name => 'Cms::Permission'
+  end
+end

data/app/models/cms/guest_user.rb

@@ -0,0 +1,57 @@
+#
+# Guests are a special user that represents a non-logged in user. The main reason to create an explicit
+# instance of this type of user is so that the permissions a Guest user can have can be set via the Admin interface.
+#
+# Every request that a non-logged in user makes will use this User's permissions to determine what they can/can't do.
+#
+module Cms
+  class GuestUser < Cms::User
+
+    def initialize(attributes={})
+      super({:login => Cms::Group::GUEST_CODE, :first_name => "Anonymous", :last_name => "User"}.merge(attributes))
+      @guest = true
+    end
+
+    def able_to?(*name)
+      group && group.permissions.count(:conditions => ["name in (?)", name.map(&:to_s)]) > 0
+    end
+
+    # Guests never get access to the CMS.
+    # Overridden from user so that able_to_view? will work correctly.
+    def cms_access?
+      false
+    end
+
+    # Return a list of the sections associated with this user that can be viewed.
+    # Overridden from user so that able_to_view? will work correctly.
+    def viewable_sections
+      group.sections
+    end
+
+    def able_to_edit?(section)
+      false
+    end
+
+    def group
+      @group ||= Cms::Group.guest
+    end
+
+    def groups
+      [group]
+    end
+
+    #You shouldn't be able to save a guest user
+    def update_attribute(name, value)
+      false
+    end
+
+    def update_attributes(attrs={})
+      false
+    end
+
+    def save(perform_validation=true)
+      false
+    end
+
+  end
+end

data/app/models/cms/html_block.rb

@@ -0,0 +1,42 @@
+module Cms
+  class HtmlBlock < ActiveRecord::Base
+
+    acts_as_content_block :taggable => true
+
+    validates_presence_of :name
+
+    # Override of search scope from searching behavior to deal with include_body
+    scope :search, lambda { |search_params|
+      term = search_params.is_a?(Hash) ? search_params[:term] : search_params
+      order = search_params.is_a?(Hash) && search_params[:order] ? search_params[:order] : table_name.to_s + ".name"
+      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]})"
+      end
+      scope = {}
+      scope[:conditions] = conditions if conditions
+      scope[:order] = order if order
+      scope
+    }
+
+    def self.display_name
+      "Text"
+    end
+
+    def self.display_name_plural
+      "Text"
+    end
+
+  end
+end

data/app/models/cms/image_block.rb

@@ -0,0 +1,11 @@
+module Cms
+  class ImageBlock < Cms::AbstractFileBlock
+
+    acts_as_content_block :belongs_to_attachment => true, :taggable => true
+
+    def self.display_name
+      "Image"
+    end
+
+  end
+end

data/app/models/cms/link.rb

@@ -0,0 +1,18 @@
+class Cms::Link < ActiveRecord::Base
+  acts_as_content_block :connectable => 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'
+
+  validates_presence_of :name
+
+  include Cms::Addressable
+  include Cms::Addressable::DeprecatedPageAccessors
+
+  #needed by menu_helper
+  def path
+    url
+  end
+
+end

data/app/models/cms/page.rb

@@ -0,0 +1,321 @@
+class Cms::Page < ActiveRecord::Base
+
+  def actual_path
+    path
+  end
+
+  is_archivable
+  flush_cache_on_change
+  is_hideable
+  is_publishable
+  uses_soft_delete
+  is_userstamped
+  is_versioned
+
+  has_many :connectors, :class_name => 'Cms::Connector', :order => "#{Cms::Connector.table_name}.container, #{Cms::Connector.table_name}.position"
+  has_many :page_routes, :class_name => 'Cms::PageRoute'
+  has_many :tasks
+
+  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
+      else
+        ver = 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]}
+    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.
+  scope :currently_connected_to, lambda { |obj|
+    connectors_table = Cms::Connector.table_name
+
+    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]}
+    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]}
+    end
+  }
+
+  has_one :section_node, :as => :node, :dependent => :destroy, :inverse_of => :node, :class_name => 'Cms::SectionNode'
+
+
+  include Cms::Addressable
+  include Cms::Addressable::DeprecatedPageAccessors
+
+
+  before_validation :append_leading_slash_to_path, :remove_trailing_slash_from_path
+  before_destroy :delete_connectors
+
+  validates_presence_of :name, :path
+
+  # Paths must be unique among undeleted records
+  validates_uniqueness_of :path, :scope=>:deleted
+  validate :path_not_reserved
+
+  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
+
+  # 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|
+      if c.connectable_type.constantize.publishable? && con = c.connectable
+        con.publish
+      end
+    end
+  end
+
+  # Each time a page is updated, we need to copy all connectors associated with it forward, and save
+  # them.
+  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")
+    logger.debug { "Found connectors #{c_found}" }
+    c_found.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?
+        logger.debug { "Connector id=>#{c.id} 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
+
+        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
+        )
+        logger.debug { "Built new connector #{new_connector}." }
+      end
+    end
+    true
+  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?
+      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
+
+  alias_method :create_connector, :add_content
+
+  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
+
+  %w(up down to_top to_bottom).each do |d|
+    define_method("move_connector_#{d}") do |connector|
+      move_connector(connector, d)
+    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(draft.version).like(connector).first
+        new_connector.destroy
+      else
+        raise "Error occurred while trying to remove connector #{connector.id}"
+      end
+    end
+  end
+
+  # 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 }
+  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
+  def revert_to(version)
+    @copy_connectors_from_version = version
+    super(version)
+  end
+
+  def file_size
+    "?"
+  end
+
+  def public?
+    section ? section.public? : false
+  end
+
+  def page_title
+    title.blank? ? name : title
+  end
+
+  def append_leading_slash_to_path
+    if path.blank?
+      self.path = "/"
+    elsif path[0, 1] != "/"
+      self.path = "/#{path}"
+    end
+  end
+
+  # remove trailing slash, unless the path is only a slash.  uses capture and
+  # substition because ruby regex engine does not support lookbehind
+  def remove_trailing_slash_from_path
+    self.path.sub!(/(.+)\/+$/, '\1')
+  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
+    Cms::PageTemplate.find_by_file_name(template_file_name)
+  end
+
+  def template_name
+    template_file_name && Cms::PageTemplate.display_name(template_file_name)
+  end
+
+  # Determines if a page is a descendant of a given Section.
+  #
+  # @param [String | Section] section_or_section_name
+  def in_section?(section_or_section_name)
+    found = false
+    ancestors.each do |a|
+      if section_or_section_name.is_a?(String)
+        if a.name == section_or_section_name
+          found = true
+          break
+        end
+      else
+        if a == section_or_section_name
+          found = true
+          break
+        end
+      end
+    end
+    found
+  end
+
+  #Returns true if the block attached to each connector in the given container are published
+  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
+
+  # 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)
+    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
+
+  # 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.
+  #
+  # @return [Section] The first non-root ancestor if available, root otherwise.
+  def top_level_section
+    # Cache the results of this since many projects will call it repeatly on current_page in menus.
+    return @top_level_section if @top_level_section
+    a = ancestors
+    @top_level_section = (a.size > 0 && a[1]) ? a[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