browsercms 3.3.4 → 3.4.0.rc1

data/app/helpers/cms/rendering_helper.rb

@@ -5,6 +5,7 @@
 module Cms
   module RenderingHelper
     def render_connector_and_connectable(connector, connectable)
+      logger.warn "Rendering #{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

data/app/helpers/cms/template_support.rb

@@ -9,9 +9,12 @@ module Cms
         
         helper Cms::PageHelper
         helper Cms::MenuHelper
+        helper Cms::RenderingHelper
         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>}
+            if current_user.able_to?(:administrate, :edit_content, :publish_content)
+              %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

data/app/helpers/cms/ui_elements_helper.rb

@@ -0,0 +1,21 @@
+module Cms
+  module UiElementsHelper
+
+    # Renders a Save And Publish button if:
+    # 1. Current User has publish rights
+    # 2. Block is publishable
+    def save_and_publish_button(block, content_type)
+      if current_user.able_to?(:publish_content) && block.publishable?
+        html = %Q{<button type="submit" name="#{content_type.content_block_type.singularize}[publish_on_save]" value="true" class="submit" tabindex="#{next_tabindex}"><span>Save And Publish</span></button>}
+        lt_button_wrapper html.html_safe
+      end
+    end
+
+
+    def select_content_type_tag(type, &block)
+      options = {:rel => "select-#{type.key}"}
+      options[:class] = "on" if content_type == type
+      content_tag_for(:li, type, nil, options, &block)
+    end
+  end
+end

data/app/models/cms/abstract_file_block.rb

@@ -0,0 +1,41 @@
+module Cms
+  class AbstractFileBlock < ActiveRecord::Base
+
+
+    set_table_name Namespacing.prefix("file_blocks")
+
+    validates_presence_of :name
+
+    scope :by_section, lambda { |section| {
+            :include => {:attachment => :section_node },
+            :conditions => ["#{SectionNode.table_name}.ancestry = ?", section.node.ancestry_path] }
+        }
+
+    # Return the parent section for this block.
+    # @return [Cms::Section]
+    def parent
+      attachment.parent
+    end
+
+    def path
+      attachment_file_path
+    end
+
+    def self.publishable?
+      true
+    end
+
+    def set_attachment_path
+      if @attachment_file_path && @attachment_file_path != attachment.file_path
+        attachment.file_path = @attachment_file_path
+      end
+    end
+
+    def set_attachment_section
+      if @attachment_section_id && @attachment_section_id != attachment.section
+        attachment.section_id = @attachment_section_id
+      end
+    end
+
+  end
+end

data/app/models/cms/attachment.rb

@@ -0,0 +1,184 @@
+require 'digest/sha1'
+require 'fileutils'
+
+module Cms
+  class Attachment < ActiveRecord::Base
+
+    #----- Constants ----------------------------------------------------------------
+    UNKNOWN_MIME_TYPE = 'application/octet-stream'
+
+    #----- Macros ----------------------------------------------------------------
+    is_archivable
+    is_publishable
+    uses_soft_delete
+    is_userstamped
+    is_versioned
+
+    # Rails 3 uses a new ActionDispatch::Http::UploadedFile. This holds that during the file processing.
+    attr_accessor :uploaded_file
+
+    # This exists for backwards compatibility
+    alias_method :temp_file, :uploaded_file
+    alias_method :temp_file=, :uploaded_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
+
+    after_save :write_temp_file_to_storage_location
+    after_save :clear_ivars
+
+
+    #----- Associations ----------------------------------------------------------
+
+    include Cms::Addressable
+    include Cms::Addressable::DeprecatedPageAccessors
+    has_one :section_node, :as => :node, :class_name => 'Cms::SectionNode'
+    alias :node :section_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
+
+    #----- Virtual Attributes ----------------------------------------------------
+
+    def section=(section)
+      dirty! if self.section != section
+      super(section)
+    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
+
+        # Some
+        if self.file_type == nil
+          self.file_type = UNKNOWN_MIME_TYPE
+        end
+      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 write_temp_file_to_storage_location
+      unless temp_file.blank?
+        actual_temp_file = temp_file.tempfile
+
+        Rails.logger.warn "I want to write out #{temp_file.tempfile}"
+        FileUtils.mkdir_p File.dirname(full_file_location)
+        if actual_temp_file.path
+          FileUtils.copy actual_temp_file.path, full_file_location
+        else
+          open(full_file_location, 'w') { |f| f << actual_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, "/tmp/uploads")
+    end
+
+    def self.storage_location=(storage_location)
+      @storage_location = storage_location
+    end
+
+    def self.find_live_by_file_path(file_path)
+      Cms::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(Cms::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
+end

data/app/models/cms/category.rb

@@ -0,0 +1,41 @@
+module Cms
+  class Category < ActiveRecord::Base
+    belongs_to :category_type, :class_name => 'Cms::CategoryType'
+    belongs_to :parent, :class_name => 'Cms::Category'
+    has_many :children, :class_name => 'Cms::Category', :foreign_key => "parent_id"
+    is_searchable
+    validates_presence_of :category_type_id, :name
+    validates_uniqueness_of :name, :scope => :category_type_id
+
+    scope :named, lambda { |name| {:conditions => ["#{table_name}.name = ?", name]} }
+    scope :of_type, lambda { |type_name| {:include => :category_type, :conditions => ["#{CategoryType.table_name}.name = ?", type_name], :order => "#{Category.table_name}.name"} }
+    scope :top_level, :conditions => ["#{Category.table_name}.parent_id is null"]
+    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 => "#{Category.table_name}.name"},
+       {:label => "Type", :method => :category_type_name, :order => "#{CategoryType.table_name}.name"},
+       {:label => "Updated On", :method => :updated_on_string, :order => "#{Category.table_name}.updated_at"}]
+    end
+  end
+end

data/app/models/cms/category_type.rb

@@ -0,0 +1,37 @@
+module Cms
+  class CategoryType < ActiveRecord::Base
+    has_many :categories, :class_name => 'Cms::Category'
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    is_searchable
+
+    scope :named, lambda { |name| {:conditions => ["#{table_name}.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_unless_one(categories.count)}"
+    end
+
+  end
+end

data/app/models/cms/connector.rb

@@ -0,0 +1,83 @@
+module Cms
+  class Connector < ActiveRecord::Base
+    belongs_to :page, :class_name => 'Cms::Page'
+    belongs_to :connectable, :polymorphic => true
+
+    acts_as_list :scope => "#{Connector.table_name}.page_id = \#{page_id} and #{Cms::Connector.table_name}.page_version = \#{page_version} and #{Cms::Connector.table_name}.container = '\#{container}'"
+    alias :move_up :move_higher
+    alias :move_down :move_lower
+
+    scope :for_page_version, lambda { |pv| {:conditions => {:page_version => pv}} }
+    scope :for_connectable_version, lambda { |cv| {:conditions => {:connectable_version => cv}} }
+    scope :for_connectable, lambda { |c|
+#    puts "Finding for_connectable for #{c.id} and #{c.class.base_class.name}"
+      {:conditions => {:connectable_id => c.id, :connectable_type => c.class.base_class.name}}
+    }
+    scope :in_container, lambda { |container| {:conditions => {:container => container}} }
+    scope :at_position, lambda { |position| {:conditions => {:position => position}} }
+    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
+end

data/app/models/cms/content_type.rb

@@ -0,0 +1,130 @@
+module Cms
+  class ContentType < ActiveRecord::Base
+    attr_accessor :group_name
+    belongs_to :content_type_group, :class_name => 'Cms::ContentTypeGroup'
+    validates_presence_of :content_type_group
+    before_validation :set_content_type_group
+
+    scope :named, lambda { |name| {:conditions => ["#{ContentType.table_name}.name = ?", name]} }
+
+    scope :connectable,
+          :include => :content_type_group,
+          :conditions => ["#{ContentTypeGroup.table_name}.name != ?", 'Categorization'],
+          :order => "#{ContentType.table_name}.priority, #{ContentType.table_name}.name"
+
+    def self.list
+      all.map { |f| f.name.underscore.to_sym }
+    end
+
+
+    # Given a 'key' like 'html_blocks' or 'portlet'. Looks first for a class in the Cms:: namespace, then again without it.
+    # Raises exception if nothing was found.
+    def self.find_by_key(key)
+      class_name = key.tableize.classify
+      content_type = find(:first, :conditions => ["name like ?", "%#{class_name}"])
+      if content_type.nil?
+        if class_name.constantize.ancestors.include?(Cms::Portlet)
+          content_type = Cms::ContentType.new(:name => class_name)
+          content_type.content_type_group = Cms::ContentTypeGroup.find_by_name('Core')
+          content_type.freeze
+          content_type
+        else
+          raise "Not a Portlet"
+        end
+      else
+        content_type
+      end
+    rescue Exception
+      if class_name.starts_with? "Cms::"
+        return self.find_by_key(class_name.gsub(/Cms::/, ""))
+      end
+      raise "Couldn't find ContentType of class '#{class_name}'"
+    end
+
+    # Returns URL friendly 'key' which is used to identify this
+    def key
+      model_class_form_name
+    end
+
+    # Returns the partial used to render the form fields for a given block.
+    def form
+      f = model_class.respond_to?(:form) ? model_class.form : "#{name.underscore.pluralize}/form"
+      if main_app_model?
+        f = "cms/#{f}"
+      end
+      f
+    end
+
+    def display_name
+      model_class.respond_to?(:display_name) ? model_class.display_name : Cms::Behaviors::Connecting.default_naming_for(model_class)
+    end
+
+    def display_name_plural
+      model_class.respond_to?(:display_name_plural) ? model_class.display_name_plural : display_name.pluralize
+    end
+
+    def model_class
+      name.constantize
+    end
+
+    # @deprecated Should be removed eventually
+    def route_name
+      if model_class.name.starts_with?("Cms")
+        model_class_form_name
+      else
+        "main_app.cms_#{model_class_form_name}"
+      end
+    end
+
+    include EngineHelper
+    def target_class
+      model_class
+    end
+
+    def path_subject
+      model_class
+    end
+
+    # Cms::HtmlBlock -> html_block
+    # ThingBlock -> thing_block
+    def model_class_form_name
+      model_class.model_name.element
+    end
+
+    # Allows models to show additional columns when being shown in a list.
+    def columns_for_index
+      if model_class.respond_to?(:columns_for_index)
+        model_class.columns_for_index.map do |column|
+          column.respond_to?(:humanize) ? {:label => column.humanize, :method => column} : column
+        end
+      else
+        [{:label => "Name", :method => :name, :order => "name"},
+         {:label => "Updated On", :method => :updated_on_string, :order => "updated_at"}]
+      end
+    end
+
+    # Used in ERB for pathing
+    def content_block_type
+      name.demodulize.pluralize.underscore
+    end
+
+    # This is used for situations where you want different to use a type for the list page
+    # This is true for portlets, where you don't want to list all portlets of a given type,
+    # You want to list all portlets
+    def content_block_type_for_list
+      if model_class.respond_to?(:content_block_type_for_list)
+        model_class.content_block_type_for_list
+      else
+        content_block_type
+      end
+    end
+
+    def set_content_type_group
+      if group_name
+        group = Cms::ContentTypeGroup.first(:conditions => {:name => group_name})
+        self.content_type_group = group || build_content_type_group(:name => group_name)
+      end
+    end
+
+  end
+end