bf4-browsercms 3.1.0

data/app/helpers/cms/path_helper.rb

@@ -0,0 +1,48 @@
+module Cms
+  module PathHelper
+    def cms_index_path_for(resource, options={})
+      send("cms_#{resource_collection_name(resource).pluralize}_path", options)
+    end
+    
+    def cms_index_url_for(resource, options={})
+      send("cms_#{resource_collection_name(resource).pluralize}_url", options)
+    end
+    
+    def cms_new_path_for(resource, options={})
+      send("new_cms_#{resource_collection_name(resource)}_path", options)
+    end
+    
+    def cms_new_url_for(resource, options={})
+      send("new_cms_#{resource_collection_name(resource)}_url", options)
+    end
+    
+    def cms_connectable_path(connectable, options={})
+      if Portlet === connectable
+        cms_portlet_path(connectable)
+      else
+        [:cms, connectable]
+      end
+    end
+    
+    def edit_cms_connectable_path(connectable, options={})
+      if Portlet === connectable
+        edit_cms_portlet_path(connectable, options)
+      else
+        polymorphic_path([:edit, :cms, connectable], options)        
+      end
+    end
+    
+    private
+      # Returns the name of the collection that this resouce belongs to
+      # the resource can be a ContentType, ActiveRecord::Base instance
+      # or just a string or symbol
+      def resource_collection_name(resource)
+        collection_name = case resource
+          when ContentType then resource.name.underscore
+          when ActiveRecord::Base then resource.class.name.underscore
+          else resource.to_s
+        end
+      end
+        
+  end
+end

data/app/helpers/cms/rendering_helper.rb

@@ -0,0 +1,38 @@
+# Provides specific helper methods to render content blocks and connectors.
+# Split off from Cms::ApplicationController so it can be included in Cms::Acts::ContentPage
+module Cms
+  module RenderingHelper
+    def render_connector_and_connectable(connector, connectable)
+      if logged_in? && @mode == "edit" && current_user.able_to_edit?(connector.page)
+        render :partial => 'cms/pages/edit_connector',
+               :locals => { :connector => connector, :connectable => connectable}
+      else
+        render_connectable(connectable)
+      end
+    end
+
+    def render_connectable(content_block)
+      if content_block
+        if content_block.class.renderable?
+          logger.info "..... Rendering connectable #{content_block.class} ##{content_block.id} #{"v#{content_block.version}" if content_block.respond_to?(:version)}"
+          content_block.perform_render(@controller)
+        else
+          logger.warn "Connectable #{content_block.class} ##{content_block.id} is not renderable"
+        end
+      else
+        logger.warn "Connectable is null"
+      end
+    rescue Exception => e
+      logger.error "Error occurred while rendering #{content_block.class}##{content_block.id}: #{e.message}\n#{e.backtrace.join("\n")}"
+      "ERROR: #{e.message}"
+    end
+
+    # Helper that will render the toolbar for the CMS.
+    # Expects:
+    #   tab - Symbol for which tab of the dashboard to highlight. Defaults to :dashboard.
+    #
+    def render_cms_toolbar(tab=:dashboard)
+      render :partial => 'layouts/cms_toolbar', :locals => {:tab => tab}
+    end
+  end
+end

data/app/helpers/cms/section_nodes_helper.rb

@@ -0,0 +1,13 @@
+module Cms
+  module SectionNodesHelper
+    def section_icons(node)
+      
+      if (node.root? || node.parent.root? || node.parent.parent.root?)
+        node.child_nodes.empty? ? image_tag("cms/sitemap/no_contents.png", :class => "no_folder_toggle large") : image_tag("cms/sitemap/gray_expand.png", :class => "folder_toggle large")
+      else
+        node.child_nodes.empty? ? image_tag("cms/sitemap/no_contents.png", :class => "no_folder_toggle") : image_tag("cms/sitemap/expand.png", :class => "folder_toggle")
+      end
+    end
+
+  end
+end

data/app/helpers/cms/template_support.rb

@@ -0,0 +1,21 @@
+# This is a module, not a helper, that is meant to be included
+# into controllers that want to use page templates for their layout
+module Cms
+  module TemplateSupport
+    def self.included(controller)
+      controller.class_eval do
+        include Cms::Authentication::Controller
+        include Cms::ErrorHandling
+        
+        helper Cms::PageHelper
+        helper Cms::MenuHelper
+        helper do
+          def cms_toolbar
+            %Q{<iframe src="#{cms_toolbar_path(:page_toolbar => 0)}" width="100%" height="100px" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" name="cms_toolbar"></iframe>}
+          end
+        end
+      end
+    end
+  end
+  
+end

data/app/models/abstract_file_block.rb

@@ -0,0 +1,17 @@
+class AbstractFileBlock < ActiveRecord::Base
+  
+  set_table_name "file_blocks"
+      
+  validates_presence_of :name  
+  
+  named_scope :by_section, lambda { |section| { :include => {:attachment => :section_node }, :conditions => ["section_nodes.section_id = ?", section.id] } } 
+  
+  def path
+    attachment_file_path
+  end
+  
+  def self.publishable?
+    true
+  end
+
+end

data/app/models/attachment.rb

@@ -0,0 +1,193 @@
+require 'digest/sha1'
+require 'fileutils'
+
+class Attachment < ActiveRecord::Base
+
+  #----- Macros ----------------------------------------------------------------
+
+  is_archivable
+  is_publishable
+  uses_soft_delete
+  is_userstamped
+  is_versioned
+  attr_accessor :temp_file
+
+  #----- Callbacks -------------------------------------------------------------
+
+  before_validation :make_dirty_if_temp_file
+  before_validation :prepend_file_path_with_slash
+  before_validation :extract_file_extension_from_file_name
+  before_validation :extract_file_type_from_temp_file
+  before_validation :extract_file_size_from_temp_file
+  before_validation :set_file_location
+  before_save :process_section
+
+  after_save :write_temp_file_to_storage_location
+  after_save :clear_ivars  
+  
+  #----- Associations ----------------------------------------------------------
+
+  has_one :section_node, :as => :node
+
+  #----- Validations -----------------------------------------------------------
+
+  validates_presence_of :temp_file, 
+    :message => "You must upload a file", :on => :create
+  validates_presence_of :file_path
+  validates_uniqueness_of :file_path
+  validates_presence_of :section_id
+    
+  #----- Virtual Attributes ----------------------------------------------------
+  
+  def section_id
+    @section_id ||= section_node ? section_node.section_id : nil
+  end
+
+  def section_id=(section_id)
+    if @section_id != section_id 
+      dirty!
+      @section_id = section_id
+    end
+  end
+
+  def section
+    @section ||= section_node ? section_node.section : nil
+  end
+
+  def section=(section)
+    if @section != section
+      dirty!
+      @section_id = section ? section.id : nil
+      @section = section
+    end
+  end
+  
+  #----- Callbacks Methods -----------------------------------------------------
+  
+  def make_dirty_if_temp_file
+    dirty! if temp_file
+  end
+  
+  def prepend_file_path_with_slash    
+    unless file_path.blank?
+      self.file_path = "/#{file_path}" unless file_path =~ /^\//
+    end
+  end
+  
+  def extract_file_extension_from_file_name
+    if file_name && file_name['.']
+      self.file_extension = file_name.split('.').last.to_s.downcase
+    end    
+  end
+  
+  def extract_file_type_from_temp_file
+    unless temp_file.blank?
+      self.file_type = temp_file.content_type
+    end    
+  end
+  
+  def extract_file_size_from_temp_file  
+    unless temp_file.blank?
+      self.file_size = temp_file.size
+    end    
+  end
+
+  # The file will be stored on disk at 
+  # Attachment.storage_location/year/month/day/sha1
+  # The sha1 is a 40 character hash based on the original_filename
+  # of the file uploaded and the current time
+  def set_file_location
+    unless temp_file.blank?
+      sha1 = Digest::SHA1.hexdigest("#{temp_file.original_filename}#{Time.now.to_f}")
+      self.file_location = "#{Time.now.strftime("%Y/%m/%d")}/#{sha1}"
+    end
+  end
+
+  def process_section
+    #logger.info "processing section, section_id => #{section_id}, section_node => #{section_node.inspect}"
+    if section_node && !section_node.new_record? && section_node.section_id != section_id
+      section_node.move_to_end(Section.find(section_id))
+    else
+      build_section_node(:node => self, :section_id => section_id)
+    end    
+  end
+    
+  def write_temp_file_to_storage_location
+    unless temp_file.blank?
+      FileUtils.mkdir_p File.dirname(full_file_location)
+      if temp_file.local_path
+        FileUtils.copy temp_file.local_path, full_file_location
+      else
+        open(full_file_location, 'w') {|f| f << temp_file.read }
+      end
+      
+      if Cms.attachment_file_permission
+        FileUtils.chmod Cms.attachment_file_permission, full_file_location
+      end
+    end
+  end  
+  
+  def clear_ivars
+    @temp_file = nil
+    @section = nil
+    @section_id = nil
+  end
+  
+  #----- Class Methods ---------------------------------------------------------
+  
+  def self.storage_location
+    @storage_location ||= File.join(Rails.root, "/uploads")
+  end
+  
+  def self.storage_location=(storage_location)
+    @storage_location = storage_location
+  end  
+  
+  def self.find_live_by_file_path(file_path)
+    Attachment.published.not_archived.first(:conditions => {:file_path => file_path})
+  end  
+  
+  #----- Instance Methods ------------------------------------------------------
+
+  def file_name
+    file_path ? file_path.split('/').last : nil
+  end
+
+  def name
+    file_name
+  end
+  
+  def icon
+    {
+        :doc => %w[doc],
+        :gif => %w[gif jpg jpeg png tiff bmp],
+        :htm => %w[htm html],
+        :pdf => %w[pdf],
+        :ppt => %w[ppt],
+        :swf => %w[swf],
+        :txt => %w[txt],
+        :xls => %w[xls],
+        :xml => %w[xml],
+        :zip => %w[zip rar tar gz tgz]
+    }.each do |icon, extensions|
+      return icon if extensions.include?(file_extension.to_s)
+    end
+    :file
+  end
+
+  def public?
+    section ? section.public? : false
+  end
+  
+  def full_file_location
+    File.join(Attachment.storage_location, file_location)
+  end
+
+  # Forces this record to be changed, even if nothing has changed
+  # This is necessary if just the section.id has changed, for example
+  def dirty!
+    # Seems like a hack, is there a better way?
+    self.updated_at = Time.now
+  end
+
+end

data/app/models/category.rb

@@ -0,0 +1,40 @@
+class Category < ActiveRecord::Base
+  belongs_to :category_type
+  belongs_to :parent, :class_name => "Category"
+  has_many :children, :class_name => "Category", :foreign_key => "parent_id"
+  is_searchable
+  validates_presence_of :category_type_id, :name
+  validates_uniqueness_of :name, :scope => :category_type_id
+  
+  named_scope :named, lambda{|name| {:conditions => ['categories.name = ?', name]}}
+  
+  named_scope :of_type, lambda{|type_name| {:include => :category_type, :conditions => ['category_types.name = ?', type_name], :order => 'categories.name'}}
+  named_scope :top_level, :conditions => ['categories.parent_id is null']
+  
+  named_scope :list, :include => :category_type
+  
+  def ancestors
+    fn = lambda do |cat, parents|
+      if cat.parent_id
+        p = self.class.find(cat.parent)
+        fn.call(p, (parents << p))
+      else
+        parents.reverse
+      end
+    end
+    fn.call(self, [])
+  end
+  
+  def path(sep=" > ")
+    (ancestors.map(&:name) + [name]).join(sep)
+  end
+  
+  def category_type_name
+    category_type ? category_type.name : nil
+  end
+  def self.columns_for_index
+    [ {:label => "Name", :method => :name, :order => "categories.name" },
+      {:label => "Type", :method => :category_type_name, :order => "category_types.name" },
+      {:label => "Updated On", :method => :updated_on_string, :order => "categories.updated_at"}  ]
+  end
+end

data/app/models/category_type.rb

@@ -0,0 +1,34 @@
+class CategoryType < ActiveRecord::Base
+  has_many :categories
+  validates_presence_of :name
+  validates_uniqueness_of :name
+  is_searchable
+  named_scope :named, lambda {|name| {:conditions => ['category_types.name = ?', name] } }
+  
+  # Return a map when the key is category type id as a string
+  # and the value is an array of arrays, each entry having 
+  # the first value as the category path and the second value
+  # being the category id as a string
+  def self.category_map
+    all.inject(Hash.new([])) do |map, ct| 
+      map[ct.id.to_s] = ct.category_list.map{|c| [c.path, c.id.to_s]}
+      map
+    end
+  end
+  
+  # This is used to get the full list of categories for this category type in the correct order.
+  def category_list(order="name")
+    list = []
+    fn = lambda do |cat|
+      list << cat
+      cat.children.all(:order => order).each{|c| fn.call(c)}
+    end
+    categories.top_level.all(:order => order).each{|cat| fn.call(cat)}
+    list
+  end
+  
+  def cannot_be_deleted_message
+    categories.count.zero? ? nil : "This cannot be deleted because it is in use in #{categories.count} #{"category".pluralize(categories.count)}"
+  end
+  
+end

data/app/models/connector.rb

@@ -0,0 +1,80 @@
+class Connector < ActiveRecord::Base
+  belongs_to :page
+  belongs_to :connectable, :polymorphic => true
+  
+  acts_as_list :scope => 'connectors.page_id = #{page_id} and connectors.page_version = #{page_version} and connectors.container = \'#{container}\''
+  alias :move_up :move_higher 
+  alias :move_down :move_lower  
+  
+  named_scope :for_page_version, lambda{|pv| {:conditions => {:page_version => pv}}}
+  named_scope :for_connectable_version, lambda{|cv| {:conditions => {:connectable_version => cv}}}
+  named_scope :for_connectable, lambda{|c| 
+    {:conditions => { :connectable_id => c.id, :connectable_type => c.class.base_class.name }}
+  }  
+  named_scope :in_container, lambda{|container| {:conditions => {:container => container}}}
+  named_scope :at_position, lambda{|position| {:conditions => {:position => position}}}  
+  named_scope :like, lambda{|connector|
+    {:conditions => { 
+      :connectable_id => connector.connectable_id, 
+      :connectable_type => connector.connectable_type,
+      :connectable_version => connector.connectable_version,
+      :container => connector.container,
+      :position => connector.position
+    }}
+  }
+  
+  validates_presence_of :page_id, :page_version, :connectable_id, :connectable_type, :container
+  
+  def current_connectable
+    if versioned?
+      connectable.as_of_version(connectable_version) if connectable
+    else
+      get_connectable
+    end
+  end
+  
+  def connectable_with_deleted
+    c = if connectable_type.constantize.respond_to?(:find_with_deleted)
+      connectable_type.constantize.find_with_deleted(connectable_id)
+    else
+      connectable_type.constantize.find(connectable_id)
+    end
+    (c && c.class.versioned?) ? c.as_of_version(connectable_version) : c
+  end
+  
+  def status
+    live? ? 'published' : 'draft'
+  end        
+
+  def status_name
+    status.to_s.titleize
+  end  
+  
+  def live?
+    if publishable?
+      connectable.live?
+    else
+      true
+    end
+  end
+  
+  def publishable?
+    connectable_type.constantize.publishable?
+  end
+  
+  def versioned?
+    connectable_type.constantize.versioned?
+  end
+
+  # Determines if a connector should be copied when a page is updated/versioned, etc.
+  #
+  # 
+  def should_be_copied?
+    if connectable && (!connectable.respond_to?(:draft) || !connectable.draft.deleted?)
+      return true
+    end
+
+
+    false
+  end
+end