browsercms 3.5.7 → 4.0.0.alpha

data/app/helpers/cms/rendering_helper.rb

@@ -5,22 +5,65 @@
 module Cms
   module RenderingHelper
 
+    def page_content_iframe(path)
+      content_tag "iframe", "" , src: path, id: 'page_content', frameborder: 0, width: '100%', height: '80%'
+      #<iframe id="page_content" src="<%= url_for engine_aware_path(@block, :inline) %>" frameborder="0" width="100%" height="80%"></iframe>
+
+    end
+    # Renders the content for the given field from the current content block.
+    # Designed to be used in Block Templates instead of direct output of fields.
+    #   Example:
+    #     <pre><%= show :content %></pre>
+    #   Instead of:
+    #     <pre><%= @content_block.content.html_safe %></pre>
+    #
+    # Why bother?: This abstracts the actual variable name (makes future upgrades more robust),
+    #   as well as let us mark up the content with html_safe,
+    #   plus conditionally make fields editable.
+    #
+    # @param [Symbol] method
+    # @param [Hash] options
+    def show(method, options={})
+      if (!is_current_user_able_to_edit_this_content?(@content_block)) # Need to check the current user can edit the page attached to this block too
+        value = @content_block.send(method)
+        value.respond_to?(:html_safe) ? value.html_safe : value
+      else
+        content_tag 'div',
+                    id: random_unique_identifier(),
+                    class: 'content-block',
+                    contenteditable: true,
+                    data: {
+                      content_name: @content_block.content_name,
+                      id: @content_block.id,
+                      attribute: method,
+                      page_id: @page.id
+
+                    } do
+          content = @content_block.send(method)
+          content.to_s.html_safe
+        end
+      end
+
+    end
+
     # Renders a table of attachments for a given content block.
     # This is intended as a basic view of the content, and probably won't be suitable for blocks that need to be added directly to pages.
     #
     def attachment_viewer(content)
-      render :partial => 'cms/attachments/attachment_table', :locals => { :block => content, :can_delete => false }
+      render :partial => 'cms/attachments/attachment_table', :locals => {:block => content, :can_delete => false}
     end
 
-    # Determines if a user is currently editing this page
-    def is_editing_page?(page)
-      logged_in? && @mode == "edit" && current_user.able_to_edit?(page)
+    # Determines if the current user can edit and is currently editing this content.
+    def is_current_user_able_to_edit_this_content?(content)
+      content && logged_in? && edit_mode? && current_user.able_to_edit?(content)
     end
-    
+
+    # @deprecated
+    alias :is_editing_page? :is_current_user_able_to_edit_this_content?
+
     def render_connector_and_connectable(connector, connectable)
-      logger.debug "Rendering #{connectable} "
-      if is_editing_page?(connector.page)
-        render(:partial => 'cms/pages/edit_connector', :locals => { :connector => connector, :connectable => connectable})
+      if is_current_user_able_to_edit_this_content?(connector.page)
+        render(:partial => 'cms/pages/edit_content', :locals => {:connector => connector, :connectable => connectable})
       else
         render_connectable(connectable)
       end
@@ -29,19 +72,24 @@ module Cms
     def render_connectable(content_block)
       if content_block
         if content_block.class.renderable?
-          logger.debug "Rendering connectable #{content_block.class} ##{content_block.id} #{"v#{content_block.version}" if content_block.respond_to?(:version)}"
+          Rails.logger.debug "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"
+          Rails.logger.warn "Connectable #{content_block.class} ##{content_block.id} is not renderable"
         end
       else
-        logger.warn "Connectable is null"
+        Rails.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")}"
+      Rails.logger.error "Error occurred while rendering #{content_block.class}##{content_block.id}: #{e.message}\n#{e.backtrace.join("\n")}"
       "ERROR: #{e.message}"
     end
 
+    # Some content doesn't have inline editing, so we need to conditionally show move up/down/remove buttons on the page
+    def content_supports_inline_editing?(connector)
+      content = connector.connectable
+      content.supports_inline_editing?
+    end
     ##
     # Renders the toolbar for the CMS. All page templates need to include this or they won't be editable.
     # Typically rendered as an iframe to avoid CSS/JS conflicts.
@@ -51,5 +99,13 @@ module Cms
     def render_cms_toolbar(tab=:dashboard)
       render :partial => 'layouts/cms_toolbar', :locals => {:tab => tab}
     end
+
+    private
+
+    # Each block needs a unique id on the page so CKeditor can attach to it. Doesn't matter what it is though.
+    # This ensure that if the same block is add twice, it will still work.
+    def random_unique_identifier
+      SecureRandom.urlsafe_base64
+    end
   end
 end

data/app/helpers/cms/section_nodes_helper.rb

@@ -1,51 +1,112 @@
 module Cms
   module SectionNodesHelper
 
-    def access_status(section_node, public_sections)
-      access_icon = :unlocked
-      unless public_sections.include?(section_node)
-        access_icon = :locked
+    def draggable_class?(modifiable_sections, section_node, parent)
+      if !section_node.root? && current_user_can_modify(modifiable_sections, section_node, parent)
+        'draggable'
+      else
+        ''
       end
-      access_icon
     end
 
-    def section_icons(section_node, children=[])
-      folder_style = ""
-      expander_image = "expand.png"
-      if top_level_section?(section_node)
-        folder_style = " large"
-        expander_image = "gray_expand.png"
+    def add_page_path_data(section_node, parent_section_node)
+      section = figure_out_target_section(parent_section_node, section_node)
+      new_section_page_path(section)
+    end
+
+    def add_link_path_data(section_node, parent_section_node)
+      section = figure_out_target_section(parent_section_node, section_node)
+      new_section_link_path(section)
+    end
+
+    def add_section_path_data(section_node, parent_section_node)
+      section = figure_out_target_section(parent_section_node, section_node)
+      new_section_path(section_id: section)
+    end
+
+    # When sitemap initially renders, we only want to show first level.
+    def initial_visibility_class(section_node)
+      section_node.depth > 1 ? 'hide' : ''
+    end
+
+    # Returns a css class for determine sitemap depth.
+    def sitemap_depth_class(section_node)
+      one_based_depth = section_node.depth + 1
+      "level-#{one_based_depth}"
+    end
+
+    # Generate HTML for 'hidden' icon for hidden content.
+    # @param [Object] content
+    # @return [String] HTML (HTML safe)
+    def hidden_icon_tag(content)
+      if content.respond_to?(:hidden?) && content.hidden?
+        '<span aria-hidden="true" class="permission-icon icon-eye-blocked"></span>'.html_safe
+      else
+        ''
       end
-      if children.empty?
-        image_tag("cms/sitemap/no_contents.png", :class => "no_folder_toggle#{folder_style}")
+    end
+
+    def guest_accessible_icon_tag(parent, content)
+      unless content.accessible_to_guests?(@public_sections, parent)
+        '<span aria-hidden="true" class="permission-icon icon-locked"></span>'.html_safe
       else
-        image_tag("cms/sitemap/#{expander_image}", :class => "folder_toggle#{folder_style}")
+        ''
       end
     end
 
-    # Renders the ul for a given node (Page/Section/Link/etc)
-    # Default look:
-    #   - First level pages/sections use 'big' icons
-    #   - All non-first level items should be hidden.
-    def sitemap_ul_tag(node)
-      opts = {
-        :id => "section_node_#{node.section_node.id}",
-        :class => "section_node"
-      }
-      opts[:class] += " rootlet" if in_first_level?(node)
-      opts[:style] = "display: none" unless in_first_level?(node)
-      tag("ul", opts, true)
+    # Generate the HTML for a given section node.
+    def icon_tag(section_node, children)
+      name = if section_node.ancestors.size == 0
+               'earth'
+             elsif section_node.home?
+               'house'
+             elsif section_node.link?
+               'link'
+             elsif section_node.page?
+               'file'
+             elsif section_node.section? && children.empty?
+               'folder-open'
+             elsif section_node.section?
+               'folder'
+             else
+               'list' # All other content types.
+             end
+      content_tag("span", "", {'aria-hidden' => true, class: "type-icon icon-#{name}"})
     end
 
-    def in_first_level?(node)
-      node.section_node.depth == 1
+    # Marks a section to determine if it can be opened/closed in the sitemap.
+    def closable_data(section_node, children)
+      if (section_node.root?)
+        false
+      elsif !children.empty?
+        true
+      else
+        false
+      end
     end
 
-    private
+    def current_user_can_modify(modifiable_sections, section_node, parent_section_node)
+      if section_node.section?
+        modifiable_sections.include?(section_node.node)
+      else
+        modifiable_sections.include?(parent_section_node.node)
+      end
+    end
 
-    def top_level_section?(node)
-      node.depth <= 2
+    # Determines if a row is leaf or folder based on whether there are any subchildren.
+    def row_type_tag(section_node)
+      section_node.section? ? 'folder' : 'leaf'
     end
 
+    private
+
+    # Need to determine if we should be adding content to a node or its parent.
+    def figure_out_target_section(parent_section_node, section_node)
+      if section_node.section?
+        section_node.node
+      else
+        parent_section_node.node
+      end
+    end
   end
 end

data/app/helpers/cms/sites/authentication_helper.rb

@@ -0,0 +1,25 @@
+module Cms
+  module Sites
+
+    # Override Devise Helpers to point to main_app rather than engine.
+    # Used for public site authentication.
+    module AuthenticationHelper
+
+      def new_session_path(resource_name)
+        main_app.new_cms_user_session_path
+      end
+
+      def session_path(resource_name)
+        main_app.cms_user_session_path
+      end
+
+      def password_path(resource_name)
+        main_app.cms_user_password_path
+      end
+
+      def new_password_path(resource_name)
+        main_app.forgot_password_path
+      end
+    end
+  end
+end

data/app/helpers/cms/sites/devise_shim_helper.rb

@@ -0,0 +1,31 @@
+module Cms
+  module Sites
+
+    # A shim that can be added to Portlet helpers to provide Devise behavior.
+    module DeviseShimHelper
+
+      # Shim to ensure main_app. is available for this helper.
+      def main_app
+        Rails.application.class.routes.url_helpers
+      end
+
+      include DeviseHelper
+
+      # Use public routes (/login) for paths
+      include Cms::Sites::AuthenticationHelper
+
+
+      def resource
+        :cms_user
+      end
+
+      def resource_name
+        :cms_user
+      end
+
+      def devise_mapping
+        @devise_mapping ||= Devise.mappings[:cms_user]
+      end
+    end
+  end
+end

data/app/helpers/cms/template_support.rb

@@ -10,13 +10,7 @@ module Cms
         helper Cms::PageHelper
         helper Cms::MenuHelper
         helper Cms::RenderingHelper
-        helper do
-          def cms_toolbar
-            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
     end
   end

data/app/helpers/cms/ui_elements_helper.rb

@@ -1,27 +1,168 @@
 module Cms
+
+  # Defines functions for creating buttons and links using the CMS styling.
+  # I.e. Menus, Save, Publish buttons and links.
   module UiElementsHelper
 
+    def cancel_button(location, label="Cancel")
+      klass = ['btn']
+      klass << 'btn-small' if location == :top
+      link_to label, :back, class: klass
+    end
+
+    def button_menu(location)
+      container_class = location == :top ? 'span6 top-buttons' : 'form-actions clearfix'
+      container_element = location == :top ? 'span' : 'div'
+      content_tag container_element, class: container_class do
+        yield if block_given?
+      end
+    end
+
+    def page_title_with_buttons(form, partial_name="buttons")
+      render(partial: partial_name, locals: {f: form, location: :top}, layout: 'page_title')
+    end
+
+    def bottom_buttons(form, partial_name="buttons")
+      render(partial: partial_name, locals: {f: form, location: :bottom}, layout: 'row')
+    end
+
+    # @deprecated Everything below.
+
     # 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
+        html = %Q{<button type="submit" name="#{content_type.content_block_type.singularize}[publish_on_save]" value="true" class="submit btn btn-primary" tabindex="#{next_tabindex}"><span>Save And Publish</span></button>}
+        html.html_safe
       end
     end
 
     # For simple publish buttons
     def publish_button(type)
-      html = %Q{<button type="submit" name="#{type}[publish_on_save]" value="true" class="submit"><span>Save And Publish</span></button>'}
-      lt_button_wrapper html.html_safe
+      html = %Q{<button type="submit" name="#{type}[publish_on_save]" value="true" class="submit btn btn-primary"><span>Save And Publish</span></button>'}
+      html.html_safe
+    end
+
+    # Renders a Publish button for the menu based on whether:
+    #   1. The current user can publish
+    #   2. The content item can or needs to be published.
+    def publish_menu_button(content_item)
+      options = {class: ["btn", "btn-primary", "http_put"], id: "publish_button"}
+      path = "#"
+      if current_user.able_to?(:publish_content) && !content_item.new_record? && content_item.respond_to?(:live?) && !content_item.live?
+        path = engine(@block).polymorphic_path([:publish, @block])
+      else
+        options[:class] << "disabled"
+      end
+      link_to "Publish", path, options
+    end
+
+    def edit_content_menu_button(content_item)
+      path = "#"
+      unless content_item.new_record?
+        path = edit_engine_aware_path(content_item)
+      end
+      link_to "Edit Content", path, class: "btn btn-primary", id: "edit_button"
+    end
+
+    def view_content_menu_button(content_item)
+      path = "#"
+      unless content_item.new_record?
+        path = engine_aware_path(content_item, nil)
+      end
+      link_to "View Content", path, class: "btn btn-primary", id: "view_button"
+    end
+
+
+    # Generic bootstrap based menu button
+    # @param [Hash] options
+    # @option options [Boolean] :enabled
+    # @option options [Array<String>] :class An array of additional classes to apply
+    def menu_button(label, path, options={})
+      defaults = {
+          enabled: true,
+          pull: 'left'
+      }
+      options = defaults.merge!(options)
+      options[:class] = %w{btn btn-primary}
+      if (options[:pull] == 'left' || options[:pull]== 'right')
+        options[:class] << "pull-#{options.delete(:pull)}"
+      end
+
+      options[:class] << 'disabled' unless options[:enabled]
+      options.delete(:enabled)
+      options[:class] << 'http_put' if options[:method] == :put
+      options[:class] << 'http_delete' if options[:method] == :delete
+      options[:class] << 'confirm_with_title' if options[:method] == :delete
+
+      options.delete(:method)
+      copy_title(options, options)
+      link_to(label, path, options)
     end
 
+    def versions_menu_button(content_item)
+      options = {class: ["btn", "btn-primary"], id: "revisions_button"}
+      path = "#"
+      if !content_item.new_record? && content_item.class.versioned?
+        path = engine(content_item).polymorphic_path([:versions, content_item])
+      else
+        options[:class] << "disabled"
+      end
+      link_to "List Versions", path, options
+    end
+
+    # Render a CMS styled 'Delete' button. This button will appear on tool bars, typically set apart visually from other buttons.
+    # Has a 'confirm?' popup attached to it as well.
+    # Assumes that javascript code to handle the 'confirm' has already been included in the page.
+    #
+    def delete_menu_button(content_item=nil, opts={class: []})
+      classes = ["btn", "http_delete", "confirm_with_title"]
+      if current_user.able_to_publish?(content_item)
+        classes << 'btn-primary'
+      else
+        classes << 'disabled'
+      end
+
+      link_to_path = "#"
+      options = {:id => 'delete_button', :class => classes}
+      options[:class].concat(opts[:class]) if opts[:class]
+
+      if content_item == nil || content_item.new_record?
+        classes << 'disabled'
+      else
+        options[:title] = "Are you sure you want to delete '#{content_item.name}'?"
+        link_to_path = engine_aware_path(content_item, nil)
+      end
+      if opts[:title]
+        options[:title] = opts[:title]
+      end
+      link_to "Delete", link_to_path, options
+    end
 
     def select_content_type_tag(type, &block)
-      options = {:rel => "select-#{type.key}"}
-      options[:class] = "on" if content_type == type
+      options = {:rel => "select-#{type.param_key}"}
+      if (defined?(content_type) && content_type == type)
+        options[:class] = "on"
+      end
       content_tag_for(:li, type, nil, options, &block)
     end
+
+    # Used by Twitter Bootstrap dropdown menus used to divide groups of menu items.
+    # @param [Integer] index
+    def divider_tag(index = 1)
+      content_tag(:li, "&nbsp;", {class: "divider"}) if index != 0
+    end
+
+    def nav_link_to(name, link, options={})
+      content_tag(:li, link_to(name, link, options))
+    end
+
+    private
+
+    def copy_title(from, to)
+      to[:title] = from[:title] if (!from[:title].blank? && from[:title].class == String)
+    end
+
   end
 end