refinerycms-pages 0.9.9.1

data/app/controllers/admin/page_parts_controller.rb

@@ -0,0 +1,24 @@
+module Admin
+  class PagePartsController < Admin::BaseController
+
+    def new
+      render :partial => "/admin/pages/page_part_field", :locals => {
+        :part => PagePart.new(:title => params[:title], :body => params[:body]),
+        :new_part => true,
+        :part_index => params[:part_index]
+      }
+    end
+
+    def destroy
+      part = PagePart.find(params[:id])
+      page = part.page
+      if part.destroy
+        page.reposition_parts!
+        render :text => "'#{part.title}' deleted."
+      else
+        render :text => "'#{part.title}' not deleted."
+      end
+    end
+
+  end
+end

data/app/controllers/admin/pages_controller.rb

@@ -0,0 +1,37 @@
+module Admin
+  class PagesController < Admin::BaseController
+
+    crudify :page,
+            :conditions => {:parent_id => nil},
+            :order => "lft ASC",
+            :include => [:parts, :slugs, :children, :parent, :translations],
+            :paging => false
+
+    rescue_from FriendlyId::ReservedError, :with => :show_errors_for_reserved_slug
+
+    def new
+      @page = Page.new
+      Page.default_parts.each_with_index do |page_part, index|
+        @page.parts << PagePart.new(:title => page_part, :position => index)
+      end
+    end
+
+  protected
+
+    def globalize!
+      Thread.current[:globalize_locale] = (params[:switch_locale] || (@page.present? && @page.slug.present? && @page.slug.locale) || ::Refinery::I18n.default_frontend_locale)
+    end
+
+    def show_errors_for_reserved_slug(exception)
+      flash[:error] = t('reserved_system_word', :scope => 'admin.pages')
+      if params[:action] == 'update'
+        find_page
+        render :edit
+      else
+        @page = Page.new(params[:page])
+        render :new
+      end
+    end
+
+  end
+end

data/app/controllers/admin/pages_dialogs_controller.rb

@@ -0,0 +1,87 @@
+require 'net/http'
+
+module Admin
+  class PagesDialogsController < Admin::DialogsController
+
+    crudify :page
+
+    def link_to
+      @pages = Page.paginate :page => params[:page],
+                             :conditions => {:parent_id => nil},
+                             :order => 'position ASC',
+                             :per_page => Page.per_page(dialog=true)
+
+      if ::Refinery::Plugins.registered.names.include?('refinery_files')
+        @resources = Resource.paginate :page => params[:resource_page],
+                                       :order => 'created_at DESC',
+                                       :per_page => Resource.per_page(dialog=true)
+
+        # resource link
+        if params[:current_link].present?
+         is_resource_link = params[:current_link].include?("/system/resources")
+        end
+      end
+
+      # web address link
+      @web_address_text = "http://"
+      @web_address_text = params[:current_link] if params[:current_link].to_s =~ /^http:\/\//
+      @web_address_target_blank = (params[:target_blank] == "true")
+
+      # mailto link
+      if params[:current_link].present?
+        if params[:current_link] =~ /^mailto:/
+          @email_address_text = params[:current_link].split("mailto:")[1].split('?')[0]
+        end
+        @email_default_subject_text = params[:current_link].split('?subject=')[1] || params[:subject]
+        @email_default_body_text = params[:current_link].split('?body=')[1] || params[:body]
+      end
+
+      if params[:paginating].present?
+        @page_area_selected = (params[:paginating] == "your_page")
+        @resource_area_selected = (params[:paginating] == "resource_file")
+      else
+        @page_area_selected = (!is_resource_link and @web_address_text == "http://" and @email_address_text.blank?)
+        @web_address_area_selected = (@web_address_text != "http://")
+        @email_address_area_selected = @email_address_text.present?
+        @resource_area_selected = is_resource_link
+      end
+    end
+
+    def test_url
+      unless params[:url].blank?
+        url = URI.parse(params[:url])
+        if url.host.nil? && params[:url].start_with?('/')
+          url.host = URI.parse(request.url).host
+        end
+
+        http = Net::HTTP.new(url.host)
+        request = Net::HTTP::Get.new(url.path.blank? ? "/" : url.path)
+
+        response = http.request request
+
+        render :json => {:result => case response
+        when Net::HTTPSuccess, Net::HTTPRedirection
+          'success'
+        else
+          'failure'
+        end }
+      end
+
+      rescue
+        render :json => {:result => 'failure'}
+    end
+
+    def test_email
+      unless params[:email].blank?
+        valid = params[:email] =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
+
+        render :json => if valid
+          {:result => 'success'}
+        else
+          {:result => 'failure'}
+        end
+      end
+    end
+
+  end
+end

data/app/controllers/pages_controller.rb

@@ -0,0 +1,31 @@
+class PagesController < ApplicationController
+
+  # This action is usually accessed with the root path, normally '/'
+  def home
+    error_404 unless (@page = Page.where(:link_url => '/').first).present?
+  end
+
+  # This action can be accessed normally, or as nested pages.
+  # Assuming a page named "mission" that is a child of "about",
+  # you can access the pages with the following URLs:
+  #
+  #   GET /pages/about
+  #   GET /about
+  #
+  #   GET /pages/mission
+  #   GET /about/mission
+  #
+  def show
+    @page = Page.find("#{params[:path]}/#{params[:id]}".split('/').last)
+
+    if @page.try(:live?) || (refinery_user? && current_user.authorized_plugins.include?("refinery_pages"))
+      # if the admin wants this to be a "placeholder" page which goes to its first child, go to that instead.
+      if @page.skip_to_first_child && (first_live_child = @page.children.order('lft ASC').where(:draft=>false).first).present?
+        redirect_to first_live_child.url
+      end
+    else
+      error_404
+    end
+  end
+
+end

data/app/helpers/pages_helper.rb

@@ -0,0 +1,2 @@
+module PagesHelper
+end

data/app/models/page.rb

@@ -0,0 +1,274 @@
+require 'globalize3'
+
+class Page < ActiveRecord::Base
+
+  translates :title, :meta_keywords, :meta_description, :browser_title if self.respond_to?(:translates)
+  attr_accessor :locale # to hold temporarily
+  validates :title, :presence => true
+
+  acts_as_nested_set
+
+  # Docs for friendly_id http://github.com/norman/friendly_id
+  has_friendly_id :title, :use_slug => true,
+                  :default_locale => (::Refinery::I18n.default_frontend_locale rescue :en),
+                  :reserved_words => %w(index new session login logout users refinery admin images wymiframe),
+                  :approximate_ascii => RefinerySetting.find_or_set(:approximate_ascii, false, :scoping => "pages")
+
+  has_many :parts,
+           :class_name => "PagePart",
+           :order => "position ASC",
+           :inverse_of => :page,
+           :dependent => :destroy
+
+  accepts_nested_attributes_for :parts, :allow_destroy => true
+
+  # Docs for acts_as_indexed http://github.com/dougal/acts_as_indexed
+  acts_as_indexed :fields => [:title, :meta_keywords, :meta_description,
+                              :custom_title, :browser_title, :all_page_part_content]
+
+  before_destroy :deletable?
+  after_save :reposition_parts!
+  after_save :invalidate_child_cached_url
+
+  scope :live, where(:draft => false)
+
+  # shows all pages with :show_in_menu set to true, but it also
+  # rejects any page that has not been translated to the current locale.
+  scope :in_menu, lambda {
+    pages = Arel::Table.new(Page.table_name)
+    translations = Arel::Table.new(Page.translations_table_name)
+
+    includes(:translations).where(:show_in_menu => true).where(
+      translations[:locale].eq(Globalize.locale)).where(pages[:id].eq(translations[:page_id]))
+  }
+
+  # when a dialog pops up to link to a page, how many pages per page should there be
+  PAGES_PER_DIALOG = 14
+
+  # when listing pages out in the admin area, how many pages should show per page
+  PAGES_PER_ADMIN_INDEX = 20
+
+  # when collecting the pages path how is each of the pages seperated?
+  PATH_SEPARATOR = " - "
+
+  # Am I allowed to delete this page?
+  # If a link_url is set we don't want to break the link so we don't allow them to delete
+  # If deletable is set to false then we don't allow this page to be deleted. These are often Refinery system pages
+  def deletable?
+    deletable && link_url.blank? and menu_match.blank?
+  end
+
+  # Repositions the child page_parts that belong to this page.
+  # This ensures that they are in the correct 0,1,2,3,4... etc order.
+  def reposition_parts!
+    parts.each_with_index do |part, index|
+      part.update_attribute(:position, index)
+    end
+  end
+
+  # Before destroying a page we check to see if it's a deletable page or not
+  # Refinery system pages are not deletable.
+  def destroy
+    if deletable?
+      super
+    else
+      unless Rails.env.test?
+        # give useful feedback when trying to delete from console
+        puts "This page is not deletable. Please use .destroy! if you really want it deleted "
+        puts "unset .link_url," if link_url.present?
+        puts "unset .menu_match," if menu_match.present?
+        puts "set .deletable to true" unless deletable
+      end
+
+      return false
+    end
+  end
+
+  # If you want to destroy a page that is set to be not deletable this is the way to do it.
+  def destroy!
+    self.menu_match = nil
+    self.link_url = nil
+    self.deletable = true
+
+    destroy
+  end
+
+  # Used for the browser title to get the full path to this page
+  # It automatically prints out this page title and all of it's parent page titles joined by a PATH_SEPARATOR
+  def path(options = {})
+    # Override default options with any supplied.
+    options = {:reversed => true}.merge(options)
+
+    unless parent.nil?
+      parts = [title, parent.path(options)]
+      parts.reverse! if options[:reversed]
+      parts.join(PATH_SEPARATOR)
+    else
+      title
+    end
+  end
+
+  # When this page is rendered in the navigation, where should it link?
+  # If a custom "link_url" is set, it uses that otherwise it defaults to a normal page URL.
+  # The "link_url" is often used to link to a plugin rather than a page.
+  #
+  # For example if I had a "Contact" page I don't want it to just render a contact us page
+  # I want it to show the Inquiries form so I can collect inquiries. So I would set the "link_url"
+  # to "/contact"
+  def url
+    if link_url.present?
+      link_url_localised?
+    elsif self.class.use_marketable_urls?
+      url_marketable
+    elsif to_param.present?
+      url_normal
+    end
+  end
+
+  def link_url_localised?
+    if link_url =~ %r{^/} and defined?(::Refinery::I18n) and ::Refinery::I18n.enabled? and
+       ::I18n.locale != ::Refinery::I18n.default_frontend_locale
+      "/#{::I18n.locale}#{link_url}"
+    else
+      link_url
+    end
+  end
+
+  def url_marketable
+    # :id => nil is important to prevent any other params[:id] from interfering with this route.
+    {:controller => '/pages', :action => 'show', :path => nested_url, :id => nil}
+  end
+
+  def url_normal
+    {:controller => '/pages', :action => 'show', :path => nil, :id => to_param}
+  end
+
+  # Returns an array with all ancestors to_param, allow with its own
+  # Ex: with an About page and a Mission underneath,
+  # Page.find('mission').nested_url would return:
+  #
+  #   ['about', 'mission']
+  #
+  def nested_url
+    Rails.cache.fetch(url_cache_key) { uncached_nested_url }
+  end
+
+  def uncached_nested_url
+    [parent.try(:nested_url), to_param].compact.flatten
+  end
+
+  # Returns the string version of nested_url, i.e., the path that should be generated
+  # by the router
+  def nested_path
+    Rails.cache.fetch(path_cache_key) { ['', nested_url].join('/') }
+  end
+
+  def path_cache_key
+    [cache_key, 'nested_path'].join('#')
+  end
+
+  def url_cache_key
+    [cache_key, 'nested_url'].join('#')
+  end
+
+  def cache_key
+    [Refinery.base_cache_key, super].join('/')
+  end
+
+  # Returns true if this page is "published"
+  def live?
+    not draft?
+  end
+
+  # Return true if this page can be shown in the navigation.
+  # If it's a draft or is set to not show in the menu it will return false.
+  def in_menu?
+    live? && show_in_menu?
+  end
+
+  # Returns true if this page is the home page or links to it.
+  def home?
+    link_url == "/"
+  end
+
+  # Returns all visible sibling pages that can be rendered for the menu
+  def shown_siblings
+    siblings.reject { |sibling| not sibling.in_menu? }
+  end
+
+  class << self
+    # Accessor to find out the default page parts created for each new page
+    def default_parts
+      RefinerySetting.find_or_set(:default_page_parts, ["Body", "Side Body"])
+    end
+
+    # Returns how many pages per page should there be when paginating pages
+    def per_page(dialog = false)
+      dialog ? PAGES_PER_DIALOG : PAGES_PER_ADMIN_INDEX
+    end
+
+    def use_marketable_urls?
+      RefinerySetting.find_or_set(:use_marketable_urls, true, :scoping => 'pages')
+    end
+  end
+
+  # Accessor method to get a page part from a page.
+  # Example:
+  #
+  #    Page.first[:body]
+  #
+  # Will return the body page part of the first page.
+  def [](part_title)
+    # don't want to override a super method when trying to call a page part.
+    # the way that we call page parts seems flawed, will probably revert to page.parts[:title] in a future release.
+    if (super_value = super).blank?
+      # self.parts is already eager loaded so we can now just grab the first element matching the title we specified.
+      part = self.parts.detect do |part|
+        part.title.present? and #protecting against the problem that occurs when have nil title
+        part.title == part_title.to_s or
+        part.title.downcase.gsub(" ", "_") == part_title.to_s.downcase.gsub(" ", "_")
+      end
+
+      return part.body unless part.nil?
+    end
+
+    super_value
+  end
+
+  # In the admin area we use a slightly different title to inform the which pages are draft or hidden pages
+  def title_with_meta
+    title = [self.title.to_s]
+    title << "<em>(#{::I18n.t('hidden', :scope => 'admin.pages.page')})</em>" unless show_in_menu?
+    title << "<em>(#{::I18n.t('draft', :scope => 'admin.pages.page')})</em>" if draft?
+
+    title.join(' ')
+  end
+
+  # Used to index all the content on this page so it can be easily searched.
+  def all_page_part_content
+    parts.collect {|p| p.body}.join(" ")
+  end
+
+  ##
+  # Protects generated slugs from title if they are in the list of reserved words
+  # This applies mostly to plugin-generated pages.
+  #
+  # Returns the sluggified string
+  def normalize_friendly_id(slug_string)
+    sluggified = super
+    if self.class.use_marketable_urls? && self.class.friendly_id_config.reserved_words.include?(sluggified)
+      sluggified << "-page"
+    end
+    sluggified
+  end
+
+  private
+
+  def invalidate_child_cached_url
+    return true unless self.class.use_marketable_urls?
+    children.each do |child|
+      Rails.cache.delete(child.url_cache_key)
+      Rails.cache.delete(child.path_cache_key)
+    end
+  end
+end