bf4-browsercms 3.1.0

data/app/models/tag.rb

@@ -0,0 +1,62 @@
+class Tag < ActiveRecord::Base
+  
+  has_many :taggings
+  
+  validates_uniqueness_of :name
+  
+  attr_accessor :size
+  is_searchable  
+  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_item.rb

@@ -0,0 +1,67 @@
+class TaskItem < ActiveRecord::Base
+  belongs_to :assigned_by, :class_name => "User"
+  belongs_to :assigned_to, :class_name => "User"
+  belongs_to :page
+  
+  after_create :mark_other_task_items_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_task_items_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_item 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_item 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 task_items")
+      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 task_items")
+      end
+    end
+
+  
+end

data/app/models/user.rb

@@ -0,0 +1,169 @@
+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 :task_items, :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
+
+  # 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 - 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
+
+  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 ||= 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
+    
+  # 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 = Section.find_by_path(object)
+       raise ActiveRecord::RecordNotFound.new("Could not find section with path = '#{object}'") unless section
+    elsif !object.is_a?(Section)
+      section = object.section
+    end
+    viewable_sections.include?(section) || cms_access?
+  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/forgot_password_portlet.rb

@@ -0,0 +1,28 @@
+class ForgotPasswordPortlet < Portlet
+  require 'digest/sha1'  
+
+  
+  def render
+    flash[:forgot_password] = {}
+
+    return unless request.method == :post
+    user = User.find_by_email(params[:email])
+    
+    unless user
+      flash[:forgot_password][:error] = "We were unable to verify your account. Please make sure your email address is accurate."
+      return
+    end
+    
+    user.reset_token = generate_reset_token
+    if user.save
+      flash[:forgot_password][:notice] = "Your password has been sent to #{params[:email]}"
+      ForgotPasswordMailer.deliver_reset_password(self.reset_password_url + '?token=' + user.reset_token, user.email)
+    end
+  end
+
+  private
+  def generate_reset_token
+    Digest::SHA1.hexdigest(Time.now.to_s.split(//).sort_by {rand}.join)
+  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/reset_password_portlet.rb

@@ -0,0 +1,28 @@
+class ResetPasswordPortlet < Portlet
+
+  def render
+    flash[:reset_password] = {}
+    
+    unless params[:token]
+      flash[:reset_password][:error] = "No password token given"
+      return
+    end
+
+    @user = User.find_by_reset_token(params[:token])
+
+    unless @user
+      flash[:reset_password][:notice] = "Invalid password token"    
+      return
+    end
+
+    if request.method == :post
+      @user.password = params[:password]
+      @user.password_confirmation = params[:password_confirmation]
+      
+      if @user.save
+        flash[:reset_password][:notice] = 'Password has been reset'
+      end
+    end
+  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 -%>