bf4-browsercms 3.1.0

data/app/models/permission.rb

@@ -0,0 +1,10 @@
+class Permission < ActiveRecord::Base
+  has_many :group_permissions
+  has_many :groups, :through => :group_permissions
+  
+  validates_presence_of :name
+  validates_uniqueness_of :name
+  
+  named_scope :named, lambda{|name| {:conditions => {:name => name}}}
+  
+end

data/app/models/portlet.rb

@@ -0,0 +1,167 @@
+class Portlet < ActiveRecord::Base
+
+  validates_presence_of :name
+  is_searchable
+
+  #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
+
+  attr_accessor :controller
+  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
+      
+      has_dynamic_attributes
+      
+      acts_as_content_block(
+        :versioned => false, 
+        :publishable => false,
+        :renderable => {:instance_variable_name_for_view => "@portlet"})
+      
+      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      
+    end      
+  end
+
+  def self.has_edit_link?
+    false
+  end
+  
+  def self.types
+    @types ||= ActiveSupport::Dependencies.load_paths.map do |d| 
+      if d =~ /app\/portlets/
+        Dir["#{d}/*_portlet.rb"].map do |p| 
+          File.basename(p, ".rb").classify
+        end
+      end
+    end.flatten.compact.uniq.sort
+  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
+  
+  #----- Portlet Action Related Methods ----------------------------------------
+  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

data/app/models/redirect.rb

@@ -0,0 +1,4 @@
+class Redirect < ActiveRecord::Base
+  validates_presence_of :from_path, :to_path
+  validates_uniqueness_of :from_path
+end

data/app/models/section.rb

@@ -0,0 +1,147 @@
+class Section < ActiveRecord::Base
+
+  flush_cache_on_change
+  
+  #The node that links this section to its parent
+  has_one :node, :class_name => "SectionNode", :as => :node, :dependent => :destroy
+  
+  #The nodes that link this section to its children
+  has_many :child_nodes, :class_name => "SectionNode"
+  has_many :child_sections, :class_name => "SectionNode", :conditions => ["node_type = ?", "Section"], :order => 'section_nodes.position'
+
+  has_many :pages, :through => :child_nodes, :source => :node, :source_type => 'Page', :order => 'section_nodes.position'
+  has_many :sections, :through => :child_nodes, :source => :node, :source_type => 'Section', :order => 'section_nodes.position'
+
+  has_many :group_sections
+  has_many :groups, :through => :group_sections
+  
+  named_scope :root, :conditions => ['root = ?', true]
+  named_scope :system, :conditions => {:name => 'system'}
+  
+  named_scope :hidden, :conditions => {:hidden => true}
+  named_scope :not_hidden, :conditions => {:hidden => false}
+  
+  named_scope :named, lambda{|name| {:conditions => ['sections.name = ?', name]}}
+  named_scope :with_path, lambda{|path| {:conditions => ['sections.path = ?', path]}}
+  
+  validates_presence_of :name, :path
+  #validates_presence_of :parent_id, :if => Proc.new {root.count > 0}, :message => "section is required"
+  
+  # Disabling '/' in section name for interoperability with FCKEditor file browser
+  validates_format_of :name, :with => /\A[^\/]*\Z/, :message => "cannot contain '/'"
+  
+  validate :path_not_reserved
+  
+  before_destroy :deletable?
+  
+  attr_accessor :full_path
+  
+  def visible_child_nodes(options={})
+    children = child_nodes.of_type(["Section", "Page", "Link"]).all(:order => 'section_nodes.position')
+    visible_children = children.select{|sn| sn.visible?}
+    options[:limit] ? visible_children[0...options[:limit]] : visible_children
+  end
+  
+  def all_children_with_name
+    child_sections.map do |s|
+      if s.node
+        s.node.full_path = root? ? s.node.name : "#{name} / #{s.node.name}"
+        [s.node] << s.node.all_children_with_name
+      end
+    end.flatten.compact
+  end
+  
+  def parent_id
+    parent ? parent.id : nil
+  end
+  
+  def parent
+    node ? node.section : nil
+  end
+  
+  def parent_id=(sec_id)
+    self.parent = Section.find(sec_id)
+  end
+  
+  def parent=(sec)
+    if node
+      node.move_to_end(sec)
+    else
+      build_node(:node => self, :section => sec)
+    end      
+  end  
+  
+  def ancestors(options={})
+    ancs = node ? node.ancestors : []
+    options[:include_self] ? ancs + [self] : ancs
+  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.reject{|n| n.orphaned?}.empty?
+  end
+  
+  def deletable?
+    !root? && empty?
+  end
+  
+  def editable_by_group?(group)
+    group.editable_by_section(self)
+  end
+  
+  def status
+    public? ? :unlocked : :locked
+  end
+  
+  def self.find_by_name_path(name_path)
+    section = Section.root.first
+    children = name_path.split("/")[1..-1] || []
+    children.each do |name|
+      section = section.sections.first(:conditions => {:name => name})
+    end
+    section
+  end
+  
+  #The first page that is a decendent of this section
+  def first_page_or_link
+    section_node = child_nodes.of_type(['Link','Page']).first(:order => "section_nodes.position")
+    return section_node.node if section_node
+    sections.each do |s| 
+      node = s.first_page_or_link
+      return node if node
+    end
+    nil
+  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
+      
+end

data/app/models/section_node.rb

@@ -0,0 +1,93 @@
+class SectionNode < ActiveRecord::Base
+  belongs_to :section
+  belongs_to :node, :polymorphic => :true
+
+  acts_as_list :scope => :section
+
+  named_scope :of_type, lambda{|types| {:conditions => ["section_nodes.node_type IN (?)", types]}}
+
+  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 == 'Section'
+  end
+
+  #Is this node a page
+  def page?
+    node_type == 'Page'
+  end
+  
+  def move_to(sec, pos)
+    #logger.info "Moving Section Node ##{id} to Section ##{sec.id} Position #{pos}"
+    transaction do
+      if section != sec
+        remove_from_list
+        self.section = sec
+        save
+      end
+      
+      if pos < 0
+        pos = 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 = SectionNode.count(:conditions => {:section_id => section_id})
+        pos = node_count if pos > node_count
+      end
+      
+      insert_at_position(pos)
+    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 ancestors()
+    ancestors = []
+    fn = lambda do |sn|
+      ancestors << sn.section
+      if sn.section && !sn.section.root?
+        fn.call(sn.section.node)
+      end
+    end
+    fn.call(self)
+    ancestors.reverse
+  end
+  
+end

data/app/models/site.rb

@@ -0,0 +1,41 @@
+class Site < ActiveRecord::Base
+  
+  validates_uniqueness_of :domain
+  
+  before_validation :remove_www
+  
+  before_save :unset_default
+  after_save :set_default
+  
+  named_scope :default, :conditions => {:the_default => true}
+    
+  def self.find_by_domain(domain)
+    d = domain.clone
+    strip_www!(d)
+    if site = first(:conditions => {:domain => d})
+      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