browsercms_s3 3.0.3

data/app/helpers/cms/menu_helper.rb

@@ -0,0 +1,158 @@
+module Cms
+  module MenuHelper
+    # Renders a menu. There are two options, neither are required:
+    # 
+    # ==== Options
+    # * <tt>:items</tt> - The items which should appear in the menu. This defaults to calling 
+    #   menu_items which generates items automatically based on the current page. But you can use 
+    #   this option to pass in a custom menu structure.
+    # * <tt>:partial</tt> - The partial used to render the menu. By default this is "partials/menu",
+    #   which can be customised through the CMS. The partial gets a local variable <tt>items</tt>.
+    #
+    # ==== Structure of items
+    #
+    # The items should be an array of hashes, in a tree. Each hash can have the following keys (name
+    # and url are required, others are optional):
+    # 
+    # * <tt>:name</tt> - The name which appears in the menu
+    # * <tt>:url</tt> - The URL to link to
+    # * <tt>:id</tt> - The id for the menu item
+    # * <tt>:selected</tt> - Boolean value to indicate whether the menu item is the current page
+    # * <tt>:target</tt> - The target attribute for the link
+    # * <tt>:children</tt> - An array of hashes containing the child menu items. This is where the
+    #   tree structure comes in.
+    def render_menu(options = {})
+      options[:items] ||= menu_items
+      options[:partial] ||= "cms/menus/menu"
+      options[:id] ||= "menu"
+      options[:class] ||= "menu"
+      render :partial => options[:partial], :locals => { :items => options[:items], :css_id => options[:id], :css_class => options[:class] }
+    end
+    
+    # This will render generate an array-of-hashes tree structure based on the page, which can be
+    # passed to render_menu in order to generate a menu.
+    # 
+    # With no options passed, it will generate a structure that includes all the child sections of 
+    # the root and then it will include the path of decendent sections all the way to the current
+    # page.
+    # 
+    # Hidden pages will not be included, but if the first page in a Section is hidden, it will be
+    # used as the URL for that Section. This is commonly done to have a page for a Section and avoid
+    # having duplicates in the navigation.
+    # 
+    # You can change the behavior with the following options, all of these are optional:
+    #
+    # ==== Options
+    # * <tt>:page</tt> - What page should be used as the current page.  If this value is omitted, 
+    #   the value in @page will be used.
+    # * <tt>:path</tt> - This will be used to look up a section and that section will used to 
+    #   generate the menu structure. The current page will still be the value of the page option or
+    #   @page. Note that this is the path to a section, not a path to a page.
+    # * <tt>:from_top</tt> - How many below levels from the root the tree should start at.  
+    #   All sections at this level will be shown.  The default is 0, which means show all
+    #   nodes that are direct children of the root
+    # * <tt>:depth</tt> - How many levels deep should the tree go, relative to from_top.  
+    #   If no value is supplied, the tree will go all the way down to the current page.
+    #   If a value is supplied, the tree will be that many levels underneath from_top deep.
+    # * <tt>:limit</tt> - Limits the number of top-level elements that will be included in the list
+    # * <tt>:show_all_siblings</tt> - Passing true for this option will make all sibilings appear in
+    #   the tree. The default is false, in which case only the siblings of nodes within the open
+    #   path will appear.
+    # 
+    # ==== Examples
+    #
+    # Assume you have the structure the NFL, which is NFL > Conference > Division > Team,
+    # with teams being a Page, everything else a Section.  Also, assume we are on the
+    # Baltimore Ravens page. If you're not a footbal fan, see http://sports.yahoo.com/nfl/teams
+    #
+    #   menu_items
+    #   # => [
+    #     { :id => "section_2", :url => "/buf", :name => "AFC", :children => [
+    #       { :id => "section_3", :url => "/buf", :name => "East" },
+    #       { :id => "section_4", :url => "/bal", :name => "North", :children => [
+    #         { :id => "page_5", :selected => true, :url => "/bal", :name => "Baltimore Ravens" },
+    #         { :id => "page_6", :url => "/cin", :name => "Cincinnati Bengals" },
+    #         { :id => "page_7", :url => "/cle", :name => "Cleveland Browns" },
+    #         { :id => "page_8", :url => "/pit", :name => "Pittsburgh Steelers" }
+    #       ] },
+    #       { :id => "section_9", :url => "/hou", :name => "South" },
+    #       { :id => "section_10}", :url => "/den", :name => "West" }
+    #       ] },
+    #     { :id => "section_11", :url => "/dal", :name => "NFC" }
+    #   ]
+    #
+    #   menu_items(:depth => 2, :show_all_siblings => true)
+    #   # => [
+    #     { :id => "section_2", :url => "/buf", :name => "AFC", :children => [
+    #         { :id => "section_3", :url => "/buf", :name => "East" },
+    #         { :id => "section_4", :url => "/bal", :name => "North" },
+    #         { :id => "section_5", :url => "/hou", :name => "South" },
+    #         { :id => "section_6", :url => "/den", :name => "West" }
+    #       ] },
+    #     { :id => "section_7", :url => "/dal", :name => "NFC", :children => [
+    #         { :id => "section_8", :url => "/dal", :name => "East" },
+    #         { :id => "section_9", :url => "/chi", :name => "North" },
+    #         { :id => "section_10", :url => "/atl", :name => "South" },
+    #         { :id => "section_11", :url => "/ari", :name => "West" }
+    #       ] }
+    #   ]
+    def menu_items(options = {})
+      # Intialize parameters
+      selected_page = options[:page] || @page
+      return nil unless selected_page
+      
+      # Path to the section
+      if options.has_key?(:path)
+        section_for_path = Section.find_by_path(options[:path])
+        raise "Could not find section for path '#{options[:path]}'" unless section_for_path
+        ancestors = section_for_path.ancestors(:include_self => true)
+      else
+        ancestors = selected_page.ancestors
+      end
+      
+      if options.has_key?(:from_top)
+        ancestors = ancestors[options[:from_top].to_i..-1] || []
+      end
+      
+      depth = options.has_key?(:depth) ? options[:depth].to_i : 1.0/0
+      show_all_siblings = options[:show_all_siblings] || false
+      
+      # We are defining a recursive lambda that takes the top-level sections
+      fn = lambda do |section_nodes, current_depth|
+        section_nodes.map do |section_node|
+          node = section_node.node
+          
+          item = {}
+          item[:selected] = true if selected_page == node
+          item[:id] = "#{section_node.node_type.underscore}_#{section_node.node_id}"
+          
+          # If we are showing a section item, we want to use the path for the first page
+          page = section_node.section? ? node.first_page_or_link : node
+          
+          item[:url] = page && page.path || '#'
+          item[:name] = node.name
+          item[:target] = "_blank" if page.respond_to?(:new_window?) && page.new_window?
+          
+          # Now if this is a section, we do the child nodes, 
+          # but only if the show_all_siblings parameter is true, 
+          # or if this section is one of the current page's ancestors
+          # and also if the current depth is less than the target depth
+          if section_node.section? &&
+             current_depth < depth &&
+             (show_all_siblings || ancestors.include?(node)) &&
+             !node.visible_child_nodes.empty?
+            item[:children] = fn.call(node.visible_child_nodes, current_depth + 1)
+          end
+          
+          item
+        end
+      end
+      
+      if ancestors.empty?
+        []
+      else
+        fn.call(ancestors.first.visible_child_nodes(:limit => options[:limit]), 1)
+      end
+    end
+  end
+end

data/app/helpers/cms/page_helper.rb

@@ -0,0 +1,68 @@
+module Cms
+  module PageHelper
+    def page_title(*args)
+      if args.first
+        @controller.instance_variable_get("@template").instance_variable_set("@page_title", args.first)
+      else
+        @controller.instance_variable_get("@template").instance_variable_get("@page_title")
+      end
+    end    
+    
+    def current_page
+      @page
+    end
+    
+    def container(name)
+      content = instance_variable_get("@content_for_#{name}")
+      if logged_in? && @page && @mode == "edit" && current_user.able_to_edit?(@page)
+        render :partial => 'cms/pages/edit_container', :locals => {:name => name, :content => content}
+      else
+        content
+      end
+    end
+    
+    def container_has_block?(name, &block)
+      has_block = (@mode == "edit") || current_page.connectable_count_for_container(name) > 0
+      logger.info "mode = #{@mode}, has_block = #{has_block}"
+      if block_given?
+        concat(capture(&block)) if has_block
+      else
+        has_block
+      end
+    end
+    
+    def cms_toolbar
+      instance_variable_get("@content_for_layout")
+    end
+    
+    def render_breadcrumbs(options={})
+      start = options[:from_top] || 0
+      show_parent = options[:show_parent].nil? ? false : options[:show_parent]
+      ancestors = current_page.ancestors
+      items = []
+      ancestors[start..ancestors.size].each_with_index do |sec,i|
+        items << content_tag(:li, 
+          link_to(h(sec.name), sec.actual_path), 
+          (i == 0 ? {:class => "first"} : {}))
+      end
+      if !show_parent && current_page.section.path == current_page.path
+        items[items.size-1] = content_tag(:li, h(current_page.section.name))
+      else
+        items << content_tag(:li, h(current_page.page_title))
+      end
+      content_tag(:ul, "\n  #{items.join("\n  ")}\n", :class => "breadcrumbs")
+    end
+    
+    def render_portlet(name)
+      portlets = Portlet.all(:conditions => ["name = ?", name.to_s])
+      if portlets.size > 1
+        @mode == "edit" ? "ERROR: Multiple Portlets with name '#{name}'" : nil
+      elsif portlets.empty?
+        @mode == "edit" ? "ERROR: No Portlet with name '#{name}'" : nil
+      else
+        render_connectable(portlets.first)
+      end
+    end
+            
+  end
+end

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/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,226 @@
+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 !Cms.file_storage_on_s3
+      if temp_file.local_path
+
+        if Cms.file_storage_on_s3
+          credentials = parse_credentials(Cms.s3_options[:s3_credentials])
+          debugger
+          s3 = RightAws::S3.new(credentials[:access_key_id], credentials[:secret_access_key] )
+          bucket = s3.bucket(Cms.s3_options[:s3_bucket], true, 'public-read')
+          key = RightAws::S3::Key.create(bucket, file_location)
+          key.put(temp_file.read,'public-read')
+        else
+          FileUtils.copy temp_file.local_path, full_file_location
+        end
+      else
+        open(full_file_location, 'w') {|f| f << temp_file.read }
+      end
+      
+      if Cms.attachment_file_permission  && !Cms.file_storage_on_s3
+        FileUtils.chmod Cms.attachment_file_permission, full_file_location
+      end
+    end
+  end  
+  
+  def parse_credentials creds
+    creds = find_credentials(creds).stringify_keys
+    (creds[RAILS_ENV] || creds).symbolize_keys
+  end
+
+  
+
+  def find_credentials creds
+    case creds
+      when File
+        YAML.load_file(creds.path)
+      when String
+        YAML.load_file(creds)
+      when Hash
+        creds
+      else
+        raise ArgumentError, "Credentials are not a path, file, or hash."
+      end
+  end
+
+  private :find_credentials 
+
+ 
+  def clear_ivars
+    @temp_file = nil
+    @section = nil
+    @section_id = nil
+  end
+  
+  #----- Class Methods ---------------------------------------------------------
+  
+  def self.storage_location
+    @storage_location ||= File.join(Rails.root, "/tmp/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