browsercms 3.3.4 → 3.4.0.rc1

data/app/models/cms/section_node.rb

@@ -0,0 +1,108 @@
+require 'ancestry'
+
+class Cms::SectionNode < ActiveRecord::Base
+  has_ancestry
+
+  # 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
+
+  scope :of_type, lambda{|types| {:conditions => ["#{table_name}.node_type IN (?)", types]}}
+  scope :in_order, :order => "position asc"
+  scope :fetch_nodes, :include => :node
+
+  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
+
+  # @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.count(:conditions => {:ancestry => ancestry})
+        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,42 @@
+module Cms
+  class Site < ActiveRecord::Base
+    validates_uniqueness_of :domain
+
+    before_validation :remove_www
+
+    before_save :unset_default
+    after_save :set_default
+
+    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
+end

data/app/models/cms/tag.rb

@@ -0,0 +1,65 @@
+module Cms
+  class Tag < ActiveRecord::Base
+    has_many :taggings, :class_name => 'Cms::Tagging'
+
+    validates_uniqueness_of :name
+
+    attr_accessor :size
+    is_searchable
+    scope :named, lambda { |tag| {:conditions => ["#{table_name}.name = ? ", tag]} }
+
+    # Returns an array of tags with a count attribute
+    #
+    # @return [Array] Each element of the area contains [Id (Integer), Name (String), count (Integer)] (with Sqlite3 anyway)
+    def self.counts(options={})
+      with_scope(:find => {
+          :select => "#{Tag.table_name}.id, #{Tag.table_name}.name, count(*) as count",
+          :joins => :taggings,
+          :group => "#{Tag.table_name}.id, #{Tag.table_name}.name",
+          :order => "count desc, #{Tag.table_name}.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
+end

data/app/models/cms/tagging.rb

@@ -0,0 +1,11 @@
+module Cms
+  class Tagging < ActiveRecord::Base
+    belongs_to :tag, :class_name => 'Cms::Tag'
+    belongs_to :taggable, :polymorphic => true, :class_name => 'Cms::Taggable', :foreign_type => 'taggable_type'
+
+    def content_type
+      Cms::ContentType.first(:conditions => {:name => taggable_type})
+    end
+
+  end
+end

data/app/models/cms/task.rb

@@ -0,0 +1,78 @@
+module Cms
+  class Task < ActiveRecord::Base
+    CANT_ASSIGN_MESSAGE = "must have permission to assign tasks"
+    CANT_BE_ASSIGNED_MESSAGE = "must have permission to be assigned tasks"
+    include Cms::DomainSupport
+    belongs_to :assigned_by, :class_name => 'Cms::User'
+    belongs_to :assigned_to, :class_name => 'Cms::User'
+    belongs_to :page, :class_name => 'Cms::Page'
+
+    after_create :mark_other_tasks_for_the_same_page_as_complete
+    after_create :send_email
+
+    scope :complete, :conditions => ["completed_at is not null"]
+    scope :incomplete, :conditions => ["completed_at is null"]
+
+    scope :for_page, lambda { |p| {:conditions => ["page_id = ?", p]} }
+    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.for_page(self.page_id.to_i).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
+        domain = SITE_DOMAIN
+        if domain =~ /^www/
+          host = domain.sub(/^www\./, "#{cms_domain_prefix}.")
+        else
+          host = "#{cms_domain_prefix}.#{domain}"
+        end
+        email = Cms::EmailMessage.create(
+            :sender => assigned_by.email,
+            :recipients => assigned_to.email,
+            :subject => "Page '#{page.name}' has been assigned to you",
+            :body => "http://#{host}#{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, CANT_ASSIGN_MESSAGE)
+      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, CANT_BE_ASSIGNED_MESSAGE)
+      end
+    end
+
+
+  end
+end

data/app/models/cms/templates.rb

@@ -0,0 +1,32 @@
+##
+# Separated into its own file so it can be required in Application Templates and Generators easier.
+module Cms
+  module Templates
+
+    ##
+    # Generates a basic empty template for a page.
+    #
+    def self.default_body
+      html = <<HTML
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
+    <title><%= page_title %></title>
+    <%= yield :html_head %>
+  </head>
+  <body style="margin: 0; padding: 0; text-align: center;">
+    <%= cms_toolbar %>
+    <div id="wrapper" style="width: 700px; margin: 0 auto; text-align: left; padding: 30px">
+      Breadcrumbs: <%= render_breadcrumbs %>
+      Main Menu: <%= render_menu %>
+      <h1><%= page_title %></h1>
+      <%= container :main %>
+    </div>
+  </body>
+</html>
+HTML
+      html
+    end
+  end
+end

data/app/models/cms/user.rb

@@ -0,0 +1,173 @@
+require 'digest/sha1'
+
+module Cms
+  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, :class_name => 'Cms::UserGroupMembership'
+    has_many :groups, :through => :user_group_memberships, :class_name => 'Cms::Group'
+    has_many :tasks, :foreign_key => "assigned_to_id", :class_name => 'Cms::Task'
+
+    scope :active, :conditions => ["expires_at IS NULL OR expires_at > ?", Time.now.utc]
+    scope :able_to_edit_or_publish_content,
+          :include => {:groups => :permissions},
+          :conditions => ["#{Permission.table_name}.name = ? OR #{Permission.table_name}.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 = {})
+      Cms::GuestUser.new(options)
+    end
+
+    def guest?
+      !!@guest
+    end
+
+    # Determines if this user should have access to the CMS administration tools. Can be overridden by specific users (like GuestUser)
+    # which may not need to check the database for that information.
+    def cms_access?
+      groups.cms_access.count > 0
+    end
+
+    def disable
+      if self.class.count(:conditions => ["expires_at is null and id != ?", id]) > 0
+        self.expires_at = Time.now - 2.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
+
+    def full_name_or_login
+      if full_name.strip.blank?
+        login
+      else
+        full_name
+      end
+    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 ||= Cms::Permission.find(:all, :include => {:groups => :users}, :conditions => ["#{User.table_name}.id = ?", id])
+    end
+
+    def viewable_sections
+      @viewable_sections ||= Cms::Section.find(:all, :include => {:groups => :users}, :conditions => ["#{User.table_name}.id = ?", id])
+    end
+
+    def modifiable_sections
+      @modifiable_sections ||= Cms::Section.find(:all, :include => {:groups => [:group_type, :users]}, :conditions => ["#{Cms::User.table_name}.id = ? and #{GroupType.table_name}.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
+
+    # Determine if this user has permission to view the specific object. Permissions
+    #   are always tied to a specific section. This method can take different input parameters
+    #   and will attempt to determine the relevant section to check.
+    # Expects object to be of type:
+    #   1. Section - Will check the user's groups to see if any of those groups can view this section.
+    #   2. Path - Will look up the section based on the path, then check it.  (Note that section paths are not currently unique, so this will check the first one it finds).
+    #   3. Other - Assumes it has a section attribute and will call that and check the return value.
+    #
+    # Returns: true if the user can view this object, false otherwise.
+    # Raises: ActiveRecord::RecordNotFound if a path to a not existent section is passed in.
+    def able_to_view?(object)
+      section = object
+      if object.is_a?(String)
+        section = Cms::Section.find_by_path(object)
+        raise ActiveRecord::RecordNotFound.new("Could not find section with path = '#{object}'") unless section
+      elsif !object.is_a?(Cms::Section)
+        section = object.section
+      end
+      viewable_sections.include?(section) || cms_access?
+    end
+
+    def able_to_modify?(object)
+      case object
+        when Cms::Section
+          modifiable_sections.include?(object)
+        when Cms::Page, Cms::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
+end