browsercms_s3 3.0.3

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
+  
+  #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

data/app/models/tag.rb

@@ -0,0 +1,62 @@
+class Tag < ActiveRecord::Base
+  
+  has_many :taggings
+  
+  validates_uniqueness_of :name
+  
+  attr_accessor :size
+  
+  named_scope :named, lambda{|tag| {:conditions => ["tags.name = ? ", tag]} }
+  
+  # Returns an array of tags with a count attribute
+  def self.counts(options={})
+    with_scope(:find => { 
+        :select => "tags.id, tags.name, count(*) as count", 
+        :joins => :taggings, 
+        :group => "tags.id, tags.name", 
+        :order => "count desc, tags.name" }) do
+      all(options)
+    end
+  end
+  
+  # Returns an array of tags with a size attribute
+  # This takes the same arguments as find, plus the additional `:sizes` option,
+  # which contols the number of sizes the tag cloud will have.
+  # The default number of sizes is 5.
+  def self.cloud(options={})
+    sizes = (options.delete(:sizes) || 5) - 1
+    sizes = 1 if sizes < 1
+    tags = counts(options)
+    return [] if tags.blank?
+    
+    min = nil
+    max = nil
+    tags.each do |t|
+      t.count = t.count.to_i
+      min = t.count if (min.nil? || t.count < min)
+      max = t.count if (max.nil? || t.count > min)
+    end
+
+    divisor = ((max - min) / sizes) + 1
+    tags.each do |t|
+      t.size = ("%1.0f" % (t.count * 1.0 / divisor)).to_i
+    end
+    
+    tags
+  end
+  
+  def tagging_count
+    taggings.count
+  end
+  
+  def self.columns_for_index
+    [ {:label => "Name", :method => :name, :order => "name" },
+      {:label => "Usages", :method => :tagging_count },
+      {:label => "Updated On", :method => :updated_on_string, :order => "updated_at"}  ]
+  end  
+  
+  def render
+    @taggings = @content_block.taggings.paginate(:page => params[:page])
+  end  
+  
+end

data/app/models/tagging.rb

@@ -0,0 +1,9 @@
+class Tagging < ActiveRecord::Base
+  belongs_to :tag
+  belongs_to :taggable, :polymorphic => true
+  
+  def content_type
+    ContentType.first(:conditions => {:name => taggable_type})
+  end
+    
+end

data/app/models/task.rb

@@ -0,0 +1,67 @@
+class Task < ActiveRecord::Base
+  belongs_to :assigned_by, :class_name => "User"
+  belongs_to :assigned_to, :class_name => "User"
+  belongs_to :page
+  
+  after_create :mark_other_tasks_for_the_same_page_as_complete
+  after_create :send_email
+  
+  named_scope :complete, :conditions => ["completed_at is not null"]
+  named_scope :incomplete, :conditions => ["completed_at is null"]
+  
+  named_scope :for_page, lambda{|p| {:conditions => ["page_id = ?", p]}}
+  named_scope :other_than, lambda{|t| {:conditions => ["id != ?", t.id]}}
+  
+  validates_presence_of :assigned_by_id, :message => "is required"
+  validates_presence_of :assigned_to_id, :message => "is required"
+  validates_presence_of :page_id, :message => "is required"
+  validate :assigned_by_is_able_to_edit_or_publish_content
+  validate :assigned_to_is_able_to_edit_or_publish_content
+  
+  def mark_as_complete!
+    update_attributes(:completed_at => Time.now)
+  end
+  
+  def completed?
+    !!completed_at
+  end
+  
+  protected
+    def mark_other_tasks_for_the_same_page_as_complete
+      self.class.other_than(self).incomplete.all.each do |t|
+        t.mark_as_complete!
+      end
+    end
+  
+    def send_email
+      #Hmm... what if the assign_by or assign_to don't have email addresses?
+      #For now we'll say just don't send an email and log that as a warning
+      if assigned_by.email.blank?
+        logger.warn "Can't send email for task because assigned by user #{assigned_by.login}:#{assigned_by.id} has no email address"
+      elsif assigned_to.email.blank?
+        logger.warn "Can't send email for task because assigned to user #{assigned_to.login}:#{assigned_to.id} has no email address"
+      else
+        email = EmailMessage.create(
+          :sender => assigned_by.email,
+          :recipients => assigned_to.email,
+          :subject => "Page '#{page.name}' has been assigned to you",
+          :body => "http://#{SITE_DOMAIN}#{page.path}\n\n#{comment}"
+        )
+      end
+      true #don't accidently return false and halt the chain
+    end
+  
+    def assigned_by_is_able_to_edit_or_publish_content
+      if assigned_by && !assigned_by.able_to_edit_or_publish_content?
+        errors.add(:assigned_by_id, "cannot assign tasks")
+      end
+    end
+
+    def assigned_to_is_able_to_edit_or_publish_content
+      if assigned_to && !assigned_to.able_to_edit_or_publish_content?
+        errors.add(:assigned_to_id, "cannot be assigned tasks")
+      end
+    end
+
+  
+end

data/app/models/user.rb

@@ -0,0 +1,143 @@
+require 'digest/sha1'
+
+class User < ActiveRecord::Base
+  include Cms::Authentication::Model
+
+  validates_presence_of     :login
+  #validates_length_of       :login,    :within => 3..40
+  validates_uniqueness_of   :login,    :case_sensitive => false
+  validates_format_of       :login,    :with => /\A\w[\w\.\-_@]+\z/, :message => "use only letters, numbers, and .-_@ please."
+
+  validates_presence_of     :email
+  #validates_length_of       :email,    :within => 6..100 #r@a.wk
+  #validates_uniqueness_of   :email,    :case_sensitive => false
+  validates_format_of       :email,    :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i, :message => "should be an email address, ex. xx@xx.com"
+  attr_accessible :login, :email, :name, :first_name, :last_name, :password, :password_confirmation, :expires_at
+
+  has_many :user_group_memberships
+  has_many :groups, :through => :user_group_memberships
+  has_many :tasks, :foreign_key => "assigned_to_id"
+    
+  named_scope :active, :conditions => {:expires_at => nil }
+  named_scope :able_to_edit_or_publish_content, 
+    :include => {:groups => :permissions}, 
+    :conditions => ["permissions.name = ? OR permissions.name = ?", "edit_content", "publish_content"]
+
+  def self.current
+    Thread.current[:cms_user]
+  end
+  def self.current=(user)
+    Thread.current[:cms_user] = user
+  end
+    
+  def self.guest(options = {})
+    GuestUser.new(options)
+  end
+
+  def guest?
+    !!@guest
+  end
+
+  def disable
+    if self.class.count(:conditions => ["expires_at is null and id != ?", id]) > 0
+      self.expires_at = Time.now - 1.minutes
+    else
+      false
+    end
+  end
+
+  def disable!
+    unless disable
+      raise "You must have at least 1 enabled user"
+    end
+    save!
+  end
+
+  def expired?
+    expires_at && expires_at <= Time.now
+  end
+
+  def enable
+    self.expires_at = nil
+  end
+
+  def enable!
+    enable
+    save!
+  end
+
+  def full_name
+    [first_name, last_name].reject{|e| e.nil?}.join(" ")
+  end
+
+  def full_name_with_login
+    "#{full_name} (#{login})"
+  end
+
+  # This is to show a formated date on the input form. I'm unsure that
+  # this is the best way to solve this, but it works.
+  def expires_at_formatted
+    expires_at ? (expires_at.strftime '%m/%d/%Y' ): nil
+  end
+
+  def permissions
+    @permissions ||= Permission.find(:all, :include => {:groups => :users}, :conditions => ["users.id = ?", id])
+  end
+
+  def viewable_sections
+    @viewable_sections ||= Section.find(:all, :include => {:groups => :users}, :conditions => ["users.id = ?", id])
+  end
+
+  def modifiable_sections
+    @modifiable_sections ||= Section.find(:all, :include => {:groups => [:group_type, :users]}, :conditions => ["users.id = ? and group_types.cms_access = ?", id, true])
+  end
+
+  # Expects a list of names of Permissions
+  # true if the user has any of the permissions
+  def able_to?(*required_permissions)
+    perms = required_permissions.map(&:to_sym)
+    permissions.any? do |p| 
+      perms.include?(p.name.to_sym) 
+    end
+  end
+    
+  # Expects object to be an object or a section
+  # If it's a section, that will be used
+  # If it's not a section, it will call section on the object
+  # returns true if any of the sections of the groups the user is in matches the page's section.
+  def able_to_view?(object)
+    section = object.is_a?(Section) ? object : object.section
+    viewable_sections.include?(section) || groups.cms_access.count > 0
+  end
+  
+  def able_to_modify?(object)
+    case object
+      when Section
+        modifiable_sections.include?(object)
+      when Page, Link
+        modifiable_sections.include?(object.section)
+      else
+        if object.class.respond_to?(:connectable?) && object.class.connectable?
+          object.connected_pages.all? { |page| able_to_modify?(page) }
+        else
+          true
+        end
+    end
+  end
+  
+  # Expects node to be a Section, Page or Link
+  # Returns true if the specified node, or any of its ancestor sections, is editable by any of 
+  # the user's 'CMS User' groups.
+  def able_to_edit?(object)    
+    able_to?(:edit_content) && able_to_modify?(object)
+  end
+  
+  def able_to_publish?(object)
+    able_to?(:publish_content) && able_to_modify?(object)
+  end
+  
+  def able_to_edit_or_publish_content?
+    able_to?(:edit_content, :publish_content)
+  end
+  
+end

data/app/models/user_group_membership.rb

@@ -0,0 +1,4 @@
+class UserGroupMembership < ActiveRecord::Base
+  belongs_to :group
+  belongs_to :user
+end

data/app/portlets/dynamic_portlet.rb

@@ -0,0 +1,7 @@
+class DynamicPortlet < Portlet
+
+  def render
+    eval(@portlet.code) unless @portlet.code.blank?
+  end
+
+end

data/app/portlets/email_page_portlet.rb

@@ -0,0 +1,24 @@
+class EmailPagePortlet < Portlet
+  
+  def render
+    pmap = flash[instance_name] || params
+    @email_message = EmailMessage.new pmap[:email_message]
+    @email_message.errors.add_from_hash flash["#{instance_name}_errors"]
+    @email_page_portlet_url = pmap[:email_page_portlet_url] || request.request_uri
+  end
+  
+  #----- Handlers --------------------------------------------------------------
+  def deliver
+    message = EmailMessage.new(params[:email_message])
+    message.subject = self.subject
+    message.body = "#{params[:email_page_portlet_url]}\n\n#{message.body}"    
+    if message.save
+      url_for_success
+    else
+      store_params_in_flash
+      store_errors_in_flash(message.errors)
+      url_for_failure
+    end
+  end
+  
+end

data/app/portlets/login_portlet.rb

@@ -0,0 +1,10 @@
+class LoginPortlet < Portlet
+  
+  def render
+    @success_url = (flash[:success_url] || self.success_url)
+    @failure_url = self.failure_url
+    @login = flash[:login] || params[:login]
+    @remember_me = flash[:remember_me] || params[:remember_me]
+  end
+    
+end

data/app/portlets/tag_cloud_portlet.rb

@@ -0,0 +1,13 @@
+class TagCloudPortlet < Portlet
+  
+  def self.default_sizes
+    (0..4).map{|n| "size-#{n}" }.join(" ")
+  end
+  
+  def render
+    @sizes = self.sizes.blank? ? self.class.default_sizes : self.sizes
+    @limit = self.limit.blank? ? 50 : self.limit
+    @cloud = Tag.cloud(:sizes => @sizes.size, :limit => @limit)
+  end
+    
+end

data/app/views/cms/blocks/_hidden_fields.html.erb

@@ -0,0 +1,10 @@
+<% if params[:_redirect_to] %>
+  <%= hidden_field_tag :_redirect_to, params[:_redirect_to] %>
+<% end -%>
+<% if @block.respond_to?(:lock_version) %>
+  <%= f.hidden_field :lock_version, :value => (@other_version ? @other_version.lock_version : @block.lock_version) %>
+<% end -%>
+<% if @block.class.connectable? %>
+  <%= f.hidden_field :connect_to_page_id %>
+  <%= f.hidden_field :connect_to_container %>
+<% end -%>

data/app/views/cms/blocks/_toolbar.html.erb

@@ -0,0 +1,9 @@
+<%= content_for :html_head, stylesheet_link_tag('cms/form_layout') %>
+
+<% content_for :functions do %>
+  <% if @block && !@block.new_record? %>
+    <%= render :partial => 'cms/blocks/toolbar_for_member' %>
+  <% else %>
+    <%= render :partial => 'cms/blocks/toolbar_for_collection' %>
+  <% end %>
+<% end %>

data/app/views/cms/blocks/_toolbar_for_collection.html.erb

@@ -0,0 +1,26 @@
+<% able_to? :publish_content do -%>
+  <%= link_to span_tag('Publish'), "#", 
+    :class => "http_put button disabled left", 
+    :id => "publish_button" %>
+<% end -%>
+
+<%= link_to span_tag("View Content"), "#", 
+  :id => "view_button", 
+  :class => "button disabled#{ ' off' if action_name == 'show'} middle" %>
+  
+<%= link_to span_tag("Edit Content"), "#", 
+  :id => "edit_button", 
+  :class => "button disabled#{ ' off' if action_name == 'edit'} right" %>
+
+<%= link_to span_tag("add new content"), cms_new_path_for(content_type), 
+  :id => "add_button", 
+  :class => "spacer button#{ ' off' if action_name == 'new'}" %>
+  
+<%= link_to span_tag("List Versions"), "#", 
+  :id => "revisions_button", 
+  :class => "button #{ action_name == 'revisions' ? ' off' : ' disabled'}" %>
+  
+<%= link_to span_tag("<span class=\"delete_img\">&nbsp;</span>Delete"), "#", 
+  :id => "delete_button", 
+  :class => "spacer button disabled http_delete confirm_with_title", 
+  :title => "Are you sure you want to delete this record?" %>