browsercms-artirix 4.0.0.rc1.art4

data/app/models/cms/portlet.rb

@@ -0,0 +1,237 @@
+module Cms
+  class Portlet < ActiveRecord::Base
+    validates_presence_of :name
+    is_searchable
+    uses_soft_delete
+    has_content_type :module => :core
+
+    # These are here simply to temporarily hold these values
+    # Makes it easy to pass them through the process of selecting a portlet type
+    attr_accessor :connect_to_page_id, :connect_to_container, :controller
+
+    # Descriptions for portlets will be displayed when a user is adding one to page, or when editing the portlet.
+    # The goal is provide a more detailed overview of how a portlet should be used or what it does.
+    # @param [String] description (If supplied, it will set the new value)
+    # @return [String]
+    def self.description(description="")
+      unless description.blank?
+        @description = description
+      end
+      if @description.blank?
+        return "(No description available)"
+      end
+      @description
+    end
+
+    delegate :request, :response, :session,
+             :flash, :params, :cookies,
+             :current_user, :logged_in?,
+             :to => :controller
+
+    def self.inherited(subclass)
+      super if defined? super
+    ensure
+      subclass.class_eval do
+        extend Cms::PolymorphicSingleTableInheritance
+
+        has_dynamic_attributes :class_name => "CmsPortletAttribute",
+                               :foreign_key => "portlet_id",
+                               :table_name => "cms_portlet_attributes",
+                               :relationship_name => :portlet_attributes
+
+        acts_as_content_block(
+            :versioned => false,
+            :publishable => false,
+            :renderable => {:instance_variable_name_for_view => "@portlet"})
+
+        # Used to skip the 'after_save' callbacks that connect blocks to pages.
+        # Portlets aren't verisonable but are connectable, so this will prevent the saving of portlets.
+        attr_accessor :skip_callbacks
+
+        def self.template_path
+          default_template_path
+        end
+
+        def self.helper_path
+          "app/portlets/helpers/#{name.underscore}_helper.rb"
+        end
+
+        def self.helper_class
+          "#{name}Helper".constantize
+        end
+
+        # Portlets don't generally support inline editing. Subclasses can override this if they do though.
+        def supports_inline_editing?
+          false
+        end
+
+
+      end
+    end
+
+    def self.has_edit_link?
+      false
+    end
+
+    # Returns an alphabetical list of classes that descend from Cms::Portlet.
+    #
+    # @return [Array<Class>]
+    def self.types
+      @types ||= ActiveSupport::Dependencies.autoload_paths.map do |d|
+        if d =~ /app\/portlets/
+          Dir["#{d}/*_portlet.rb"].map do |p|
+            File.basename(p, ".rb").classify.constantize
+          end
+        end
+      end.flatten.compact.uniq
+      @types.sort! { |a,b| a.name.downcase <=> b.name.downcase }
+      @types.select! { |type| !blacklist.include?(type.name)}
+      @types
+    end
+
+    # Determines if a content_type is blacklisted or not.
+    #
+    # @param [Symbol] type (:dynamic_portlet)
+    def self.blacklisted?(type_name)
+      blacklist.include?(type_name.to_s.camelize)
+    end
+
+    # Returns a blacklist of all content types that shouldn't be accessible. Includes both portlets and other CMS types.
+    #
+    # @return [Array<String>] List of class names ['DynamicPortlet', 'LoginPortlet']
+    def self.blacklist
+      @blacklist ||= Rails.configuration.cms.content_types.blacklist.map {|underscore_name| underscore_name.to_s.camelize }
+    end
+
+    def self.get_subclass(type)
+      raise "Unknown Portlet Type" unless types.map(&:name).include?(type)
+      type.constantize
+    end
+
+    # For column in list
+    def portlet_type_name
+      type.titleize
+    end
+
+    def self.form
+      "portlets/#{name.tableize.sub('_portlets', '')}/form"
+    end
+
+    def self.default_template
+      template_file = ActionController::Base.view_paths.map do |vp|
+        path = vp.to_s.first == "/" ? vp.to_s : Rails.root.join(vp.to_s)
+        Dir[File.join(path, default_template_path) + '.*']
+      end.flatten.first
+      template_file ? open(template_file) { |f| f.read } : ""
+    end
+
+    def self.set_default_template_path(s)
+      @default_template_path = s
+    end
+
+    def self.default_template_path
+      @default_template_path ||= "portlets/#{name.tableize.sub('_portlets', '')}/render"
+    end
+
+    # Called by 'render' to determine if this portlet should render itself using a file (render.html.erb) or using
+    # its 'template' attribute.
+    def inline_options
+      options = {}
+      options[:inline] = self.template if self.class.render_inline && !(self.template.nil? || self.template.blank?)
+      options[:type] = self.handler unless self.handler.blank?
+      options
+    end
+
+    def self.handler(handler_type)
+      define_method(:handler) { handler_type }
+    end
+
+    # Determines if the template editor in the CMS UI will be enabled when creating or editing instances of this portlet
+    # If enabled, the portlet will use the template code stored in the database. If not, it will render from the render.html.erb
+    # file created.
+    def self.enable_template_editor (enabled)
+      render_inline enabled
+    end
+
+    def self.render_inline(*args)
+      if args.length > 0
+        @render_inline = args.first
+      elsif !defined?(@render_inline)
+        @render_inline = true
+      else
+        @render_inline
+      end
+    end
+
+    def type_name
+      type.to_s.titleize
+    end
+
+    def self.columns_for_index
+      [{:label => "Name", :method => :name, :order => "name"},
+       {:label => "Type", :method => :type_name, :order => "type"},
+       {:label => "Updated On", :method => :updated_on_string, :order => "updated_at"}]
+    end
+
+    # Duck typing (like a ContentBlock) for determining if this block should have a usages link or not.
+    def self.connectable?
+      true
+    end
+
+    # For polymorphic permissions
+    # A generic portlet shouldn't be connected to pages.
+    def connected_pages
+      []
+    end
+
+    #----- Portlet Action Related Methods ----------------------------------------
+
+    # Used by portlets to set a custom title, typically in the render body.
+    # For example, this allows a page with a single portlet that might display a content block to set the page name to
+    # that block name.
+    def page_title(new_title)
+      controller.current_page.title = new_title
+    end
+
+    def instance_name
+      "#{self.class.name.demodulize.underscore}_#{id}"
+    end
+
+    def url_for_success
+      [params[:success_url], self.success_url, request.referer].detect do |e|
+        !e.blank?
+      end
+    end
+
+    def url_for_failure
+      [params[:failure_url], self.failure_url, request.referer].detect do |e|
+        !e.blank?
+      end
+    end
+
+    # This will copy all the params from this request into the flash.
+    # The key in the flash with be the portlet instance_name and
+    # the value will be the hash of all the params, except the params
+    # that have values that are a StringIO or a Tempfile will be left out.
+    def store_params_in_flash
+      store_hash_in_flash instance_name, params
+    end
+
+    # This will convert the errors object into a hash and then store it
+    # in the flash under the key #{portlet.instance_name}_errors
+    def store_errors_in_flash(errors)
+      store_hash_in_flash("#{instance_name}_errors",
+                          errors.inject({}) { |h, (k, v)| h[k] = v; h })
+    end
+
+    def store_hash_in_flash(key, hash)
+      flash[key] = hash.inject(HashWithIndifferentAccess.new) do |p, (k, v)|
+        unless StringIO === v || Tempfile === v
+          p[k.to_sym] = v
+        end
+        p
+      end
+    end
+
+  end
+end

data/app/models/cms/redirect.rb

@@ -0,0 +1,12 @@
+module Cms
+  class Redirect < ActiveRecord::Base
+    validates_presence_of :from_path, :to_path
+    validates_uniqueness_of :from_path
+
+    def self.from(path)
+      where(:from_path => path).first
+    end
+
+    extend DefaultAccessible
+  end
+end

data/app/models/cms/search_filter.rb

@@ -0,0 +1,18 @@
+module Cms
+  # Captures values for the search form.
+  class SearchFilter
+    include ::ActiveModel::Model
+
+    attr_accessor :model_class, :term
+
+    def self.build(params_hash, model_class)
+      model = self.new(params_hash)
+      model.model_class = model_class
+      model
+    end
+
+    def path
+      model_class
+    end
+  end
+end

data/app/models/cms/section.rb

@@ -0,0 +1,224 @@
+module Cms
+  class Section < ActiveRecord::Base
+    flush_cache_on_change
+
+    is_addressable no_dynamic_path: true, destroy_if: :deletable?
+    # Cannot use dependent => :destroy to do this. Ancestry's callbacks trigger before the before_destroy callback.
+    #   So sections would always get deleted since deletable? would return true
+    after_destroy :destroy_node
+    before_destroy :deletable?
+
+    SECTION = "Cms::Section"
+    PAGE = "Cms::Page"
+    LINK = "Cms::Link"
+    VISIBLE_NODE_TYPES = [SECTION, PAGE, LINK]
+    HIDDEN_NODE_TYPES = "Cms::Attachment"
+
+    extend DefaultAccessible
+    # @override
+    def self.permitted_params
+      super + [:allow_groups, group_ids: []]
+    end
+
+    has_many :group_sections, :class_name => 'Cms::GroupSection'
+    has_many :groups, :through => :group_sections, :class_name => 'Cms::Group'
+
+    scope :root, -> { where(['root = ?', true]) }
+    scope :system, -> { where({:name => 'system'}) }
+    scope :hidden, -> { where({:hidden => true}) }
+    scope :not_hidden, -> { where({:hidden => false}) }
+
+    def self.named(name)
+      where(["#{table_name}.name = ?", name])
+    end
+
+    def self.with_path(path)
+      where(["#{table_name}.path = ?", path])
+    end
+
+    #scope :named, lambda { |name| {-> {where( ["#{table_name}.name = ?", name]} }   )}
+    #scope :with_path, lambda { |path| {-> {where( ["#{table_name}.path = ?", path]} }    )}
+
+    validates_presence_of :name, :path
+
+    # Disabling '/' in section name for interoperability with FCKEditor file browser
+    validates_format_of :name, :with => /\A[^\/]*\Z/, :message => "cannot contain '/'"
+
+    validate :path_not_reserved
+
+    attr_accessor :full_path
+
+    delegate :ancestry_path, :to => :node
+
+    def ancestry
+      self.node.ancestry
+    end
+
+    before_validation :ensure_section_node_exists
+
+    def ensure_section_node_exists
+      unless node
+        self.node = build_section_node
+      end
+    end
+
+    # Returns a list of all children which are sections.
+    # @return [Array<Section>]
+    def sections
+      child_nodes.of_type(SECTION).fetch_nodes.in_order.collect do |section_node|
+        section_node.node
+      end
+    end
+
+    alias :child_sections :sections
+
+    # Since #sections isn't an association anymore, callers can use this rather than #sections.build
+    def build_section
+      Section.new(:parent => self)
+    end
+
+    # Used by the sitemap to find children to iterate over.
+    def child_nodes
+      self.node.children
+    end
+
+    def pages
+      child_pages = self.node.children.collect do |section_node|
+        section_node.node if section_node.page?
+      end
+      child_pages.compact
+    end
+
+    def self.sitemap
+      SectionNode.not_of_type(HIDDEN_NODE_TYPES).fetch_nodes.arrange(:order => :position)
+    end
+
+    def visible_child_nodes(options={})
+      children = child_nodes.of_type(VISIBLE_NODE_TYPES).fetch_nodes.in_order.to_a
+      visible_children = children.select { |sn| sn.visible? }
+      options[:limit] ? visible_children[0...options[:limit]] : visible_children
+    end
+
+
+    # Returns a complete list of all sections that are desecendants of this sections, in order, as a single flat list.
+    # Used by Section selectors where users have to pick a single section from a complete list of all sections.
+    def master_section_list
+      sections.map do |section|
+        section.full_path = root? ? section.name : "#{name} / #{section.name}"
+        [section] << section.master_section_list
+      end.flatten.compact
+    end
+
+    def parent_id
+      parent ? parent.id : nil
+    end
+
+    def parent_id=(sec_id)
+      self.parent = Section.find(sec_id)
+    end
+
+    def with_ancestors(options = {})
+      options.merge! :include_self => true
+      self.ancestors(options)
+    end
+
+    def move_to(section)
+      if root?
+        false
+      else
+        node.move_to_end(section)
+      end
+    end
+
+    def public?
+      !!(groups.find_by_code('guest'))
+    end
+
+    def empty?
+      child_nodes.empty?
+    end
+
+    # Callback to determine if this section can be deleted.
+    def deletable?
+      !root? && empty?
+    end
+
+    def editable_by_group?(group)
+      group.editable_by_section(self)
+    end
+
+    def status
+      @status ||= public? ? :unlocked : :locked
+    end
+
+    # Used by the file browser to look up a section by the combined names as a path.
+    #   i.e. /A/B/
+    # @return [Section] nil if not found
+    def self.find_by_name_path(name_path)
+      current_section = Cms::Section.root.first
+      path_names = name_path.split("/")[1..-1] || []
+
+      # This implementation is very slow as it has to loop over the entire tree in memory to match each name element.
+      path_names.each do |name|
+        current_section.sections.each do |s|
+          current_section = s if s.name == name
+        end
+      end
+      current_section
+    end
+
+    #The first page that is a descendent of this section
+    def first_page_or_link
+      types = Cms::ContentType.addressable.collect(&:name).push(LINK).push(PAGE)
+      section_node = child_nodes.of_type(types).fetch_nodes.in_order.first
+      return section_node.node if section_node
+      sections.each do |s|
+        node = s.first_page_or_link
+        return node if node
+      end
+      nil
+    end
+
+    # Returns the path for this section with a trailing slash
+    def prependable_path
+      if path.ends_with?("/")
+        path
+      else
+        "#{path}/"
+      end
+    end
+
+    def actual_path
+      if root?
+        "/"
+      else
+        p = first_page_or_link
+        p ? p.path : "#"
+      end
+    end
+
+    def path_not_reserved
+      if Cms.reserved_paths.include?(path)
+        errors.add(:path, "is invalid, '#{path}' a reserved path")
+      end
+    end
+
+    ##
+    # Set which groups are allowed to access this section.
+    # @param [Symbol] code Set of groups to allow (Options :all, :none) Defaults to :none
+    def allow_groups=(code=:none)
+      if code == :all
+        self.groups = Cms::Group.all
+      end
+    end
+
+    # Sections are accessible to guests if they marked as such. Variables are passed in for performance reasons
+    # since this gets called 'MANY' times on the sitemap.
+    #
+    # @param [Array<Section>] public_sections
+    # @param [Section] parent
+    def accessible_to_guests?(public_sections, parent)
+      public_sections.include?(self)
+    end
+  end
+end

data/app/models/cms/section_node.rb

@@ -0,0 +1,144 @@
+require 'ancestry'
+
+class Cms::SectionNode < ActiveRecord::Base
+  has_ancestry
+
+  validates :slug, uniqueness: { scope: :node_type }, unless: lambda { |sn| sn.slug.blank?}
+
+  # This is the parent section for this node
+  # For backwards compatiblity
+  def parent_section
+    self.parent ? self.parent.node : nil
+  end
+
+  alias :section :parent_section
+
+  # For backwards compatiblity
+  def section=(new_section)
+    self.parent = new_section.node
+  end
+
+  # The item this node links to
+  belongs_to :node, :polymorphic => :true, :inverse_of => :section_node
+
+  acts_as_list
+  # For acts_as_list. Specifies that position should be unique within a section.
+  def scope_condition
+    ancestry ? "ancestry = '#{ancestry}'" : 'ancestry IS NULL'
+  end
+
+
+  class << self
+    def of_type(types)
+      where(["#{table_name}.node_type IN (?)", types])
+    end
+
+    def in_order
+      order("position asc")
+    end
+
+    def fetch_nodes
+      includes(:node)
+    end
+  end
+
+  # Return all section nodes which are not of the given type (i.e. class name)
+  # @param [String] klass A specific class name that should be excluded.
+  def self.not_of_type(klass)
+    where("#{table_name}.node_type NOT IN (?)", klass)
+  end
+
+  # Determines if this node is the homepage of the site.
+  def home?
+    page? && node.home?
+  end
+
+  def visible?
+    return false unless node
+    return false if (node.respond_to?(:hidden?) && node.hidden?)
+    return false if (node.respond_to?(:archived?) && node.archived?)
+    return false if (node.respond_to?(:published?) && !node.published?)
+    true
+  end
+
+  def orphaned?
+    !node || (node.class.uses_soft_delete? && node.deleted?)
+  end
+
+  #Is this node a section
+  def section?
+    node_type == 'Cms::Section'
+  end
+
+  #Is this node a page
+  def page?
+    node_type == 'Cms::Page'
+  end
+
+  def link?
+    node_type == 'Cms::Link'
+  end
+  
+  def deletable?
+    return false if self.root?
+    if node.respond_to?(:deletable?)
+      return node.deletable?
+    end
+    true
+  end
+
+  # @param [Section] section
+  # @param [Integer] position
+  def move_to(section, position)
+    #logger.info "Moving Section Node ##{id} to Section ##{sec.id} Position #{pos}"
+    transaction do
+      if self.parent != section.node
+        remove_from_list
+        self.parent = section.node
+        save
+      end
+      if position < 0
+        position = 0
+      else
+        #This helps prevent the position from getting out of whack
+        #If you pass in a really high number for position, 
+        #this just corrects it to the right number
+        node_count = Cms::SectionNode.where({:ancestry => ancestry}).count
+        position = node_count if position > node_count
+      end
+      
+      insert_at_position(position)
+    end
+  end
+
+  def move_before(section_node)
+    if section == section_node.section && position < section_node.position
+      pos = section_node.position - 1
+    else
+      pos = section_node.position
+    end
+    move_to(section_node.section, pos)
+  end
+
+  def move_after(section_node)
+    if section == section_node.section && position < section_node.position
+      pos = section_node.position
+    else
+      pos = section_node.position + 1
+    end
+    move_to(section_node.section, pos)
+  end
+
+  def move_to_beginning(sec)
+    move_to(sec, 0)
+  end
+
+  def move_to_end(sec)
+    #1.0/0 == Infinity
+    move_to(sec, 1.0/0)
+  end
+
+  def ancestry_path
+    path_ids.join "/"
+  end
+end

data/app/models/cms/site.rb

@@ -0,0 +1,45 @@
+module Cms
+  class Site < ActiveRecord::Base
+
+   #attr_accessible :name, :domain
+
+    validates_uniqueness_of :domain
+
+    before_validation :remove_www
+
+    before_save :unset_default
+    after_save :set_default
+
+    scope :default, -> {where(:the_default => true)}
+
+    def self.find_by_domain(domain)
+      d = domain.clone
+      strip_www!(d)
+      if site = where(:domain => d).first
+        site
+      else
+        default.first
+      end
+    end
+
+    def self.strip_www!(d)
+      return unless d
+      d.sub!(/\Awww./, '')
+    end
+
+    def remove_www
+      self.class.strip_www!(domain)
+    end
+
+    def unset_default
+      self.class.update_all(["the_default = ?", false]) if the_default
+    end
+
+    def set_default
+      if self.class.default.count < 1
+        update_attribute(:the_default, true)
+      end
+    end
+
+  end
+end