browsercmsi 3.1.0

data/lib/acts_as_list.rb

@@ -0,0 +1,256 @@
+module ActsAsList
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # This +acts_as+ extension provides the capabilities for sorting and reordering a number of objects in a list.
+  # The class that has this specified needs to have a +position+ column defined as an integer on
+  # the mapped database table.
+  #
+  # Todo list example:
+  #
+  #   class TodoList < ActiveRecord::Base
+  #     has_many :todo_items, :order => "position"
+  #   end
+  #
+  #   class TodoItem < ActiveRecord::Base
+  #     belongs_to :todo_list
+  #     acts_as_list :scope => :todo_list
+  #   end
+  #
+  #   todo_list.first.move_to_bottom
+  #   todo_list.last.move_higher
+  module ClassMethods
+    # Configuration options are:
+    #
+    # * +column+ - specifies the column name to use for keeping the position integer (default: +position+)
+    # * +scope+ - restricts what is to be considered a list. Given a symbol, it'll attach <tt>_id</tt> 
+    #   (if it hasn't already been added) and use that as the foreign key restriction. It's also possible 
+    #   to give it an entire string that is interpolated if you need a tighter scope than just a foreign key.
+    #   Example: <tt>acts_as_list :scope => 'todo_list_id = #{todo_list_id} AND completed = 0'</tt>
+    def acts_as_list(options = {})
+      configuration = { :column => "position", :scope => "1 = 1" }
+      configuration.update(options) if options.is_a?(Hash)
+
+      configuration[:scope] = "#{configuration[:scope]}_id".intern if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
+
+      if configuration[:scope].is_a?(Symbol)
+        scope_condition_method = %(
+          def scope_condition
+            if #{configuration[:scope].to_s}.nil?
+              "#{configuration[:scope].to_s} IS NULL"
+            else
+              "#{configuration[:scope].to_s} = \#{#{configuration[:scope].to_s}}"
+            end
+          end
+        )
+      else
+        scope_condition_method = "def scope_condition() \"#{configuration[:scope]}\" end"
+      end
+
+      class_eval <<-EOV
+        include ActsAsList::InstanceMethods
+
+        def acts_as_list_class
+          ::#{self.name}
+        end
+
+        def position_column
+          '#{configuration[:column]}'
+        end
+
+        #{scope_condition_method}
+
+        before_destroy :remove_from_list_without_saving
+        before_create  :add_to_list_bottom
+      EOV
+    end
+  end
+
+  # All the methods available to a record that has had <tt>acts_as_list</tt> specified. Each method works
+  # by assuming the object to be the item in the list, so <tt>chapter.move_lower</tt> would move that chapter
+  # lower in the list of all chapters. Likewise, <tt>chapter.first?</tt> would return +true+ if that chapter is
+  # the first in the list of all chapters.
+  module InstanceMethods
+    # Insert the item at the given position (defaults to the top position of 1).
+    def insert_at(position = 1)
+      insert_at_position(position)
+    end
+
+    # Swap positions with the next lower item, if one exists.
+    def move_lower
+      lower = lower_item
+      return unless lower
+      acts_as_list_class.transaction do
+        self.update_attribute(position_column, lower.send(position_column))
+        lower.decrement_position
+      end
+    end
+
+    # Swap positions with the next higher item, if one exists.
+    def move_higher
+      higher = higher_item
+      return unless higher
+      acts_as_list_class.transaction do
+        self.update_attribute(position_column, higher.send(position_column))
+        higher.increment_position
+      end
+    end
+
+    # Move to the bottom of the list. If the item is already in the list, the items below it have their
+    # position adjusted accordingly.
+    def move_to_bottom
+      return unless in_list?
+      acts_as_list_class.transaction do
+        decrement_positions_on_lower_items
+        assume_bottom_position
+      end
+    end
+
+    # Move to the top of the list. If the item is already in the list, the items above it have their
+    # position adjusted accordingly.
+    def move_to_top
+      return unless in_list?
+      acts_as_list_class.transaction do
+        increment_positions_on_higher_items
+        assume_top_position
+      end
+    end
+
+    # Removes the item from the list.
+    def remove_from_list(save = true)
+      if in_list?
+        decrement_positions_on_lower_items
+        update_attribute(position_column, nil) if save
+      end
+    end
+
+    def remove_from_list_without_saving
+      self.remove_from_list(false)
+    end
+
+    # Increase the position of this item without adjusting the rest of the list.
+    def increment_position
+      return unless in_list?
+      update_attribute position_column, self.send(position_column).to_i + 1
+    end
+
+    # Decrease the position of this item without adjusting the rest of the list.
+    def decrement_position
+      return unless in_list?
+      update_attribute position_column, self.send(position_column).to_i - 1
+    end
+
+    # Return +true+ if this object is the first in the list.
+    def first?
+      return false unless in_list?
+      self.send(position_column) == 1
+    end
+
+    # Return +true+ if this object is the last in the list.
+    def last?
+      return false unless in_list?
+      self.send(position_column) == bottom_position_in_list
+    end
+
+    # Return the next higher item in the list.
+    def higher_item
+      return nil unless in_list?
+      acts_as_list_class.find(:first, :conditions =>
+        "#{scope_condition} AND #{position_column} < #{send(position_column).to_s}", :order => "#{position_column} DESC"
+      )
+    end
+
+    # Return the next lower item in the list.
+    def lower_item
+      return nil unless in_list?
+      acts_as_list_class.find(:first, :conditions =>
+        "#{scope_condition} AND #{position_column} > #{send(position_column).to_s}", :order => "#{position_column} ASC"
+      )
+    end
+
+    # Test if this record is in a list
+    def in_list?
+      !send(position_column).nil?
+    end
+
+    private
+      def add_to_list_top
+        increment_positions_on_all_items
+      end
+
+      def add_to_list_bottom
+        self[position_column] = bottom_position_in_list.to_i + 1
+      end
+
+      # Overwrite this method to define the scope of the list changes
+      def scope_condition() "1" end
+
+      # Returns the bottom position number in the list.
+      #   bottom_position_in_list    # => 2
+      def bottom_position_in_list(except = nil)
+        item = bottom_item(except)
+        item ? item.send(position_column) : 0
+      end
+
+      # Returns the bottom item
+      def bottom_item(except = nil)
+        conditions = scope_condition
+        conditions = "#{conditions} AND #{self.class.primary_key} != #{except.id}" if except
+        acts_as_list_class.find(:first, :conditions => conditions, :order => "#{position_column} DESC")
+      end
+
+      # Forces item to assume the bottom position in the list.
+      def assume_bottom_position
+        update_attribute(position_column, bottom_position_in_list(self).to_i + 1)
+      end
+
+      # Forces item to assume the top position in the list.
+      def assume_top_position
+        update_attribute(position_column, 1)
+      end
+
+      # This has the effect of moving all the higher items up one.
+      def decrement_positions_on_higher_items(position)
+        acts_as_list_class.update_all(
+          "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} <= #{position}"
+        )
+      end
+
+      # This has the effect of moving all the lower items up one.
+      def decrement_positions_on_lower_items
+        return unless in_list?
+        acts_as_list_class.update_all(
+          "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}"
+        )
+      end
+
+      # This has the effect of moving all the higher items down one.
+      def increment_positions_on_higher_items
+        return unless in_list?
+        acts_as_list_class.update_all(
+          "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}"
+        )
+      end
+
+      # This has the effect of moving all the lower items down one.
+      def increment_positions_on_lower_items(position)
+        acts_as_list_class.update_all(
+          "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} >= #{position}"
+       )
+      end
+
+      # Increments position (<tt>position_column</tt>) of all items in the list.
+      def increment_positions_on_all_items
+        acts_as_list_class.update_all(
+          "#{position_column} = (#{position_column} + 1)",  "#{scope_condition}"
+        )
+      end
+
+      def insert_at_position(position)
+        remove_from_list
+        increment_positions_on_lower_items(position)
+        self.update_attribute(position_column, position)
+      end
+  end
+end

data/lib/browsercms.rb

@@ -0,0 +1,12 @@
+require 'cms/extensions'
+require 'cms/init'
+require 'cms/routes'
+require 'cms/caching'
+
+#Load libraries that are included with CMS
+require 'acts_as_list'
+ActiveRecord::Base.send(:include, ActsAsList)
+
+#Include CMS Behaviors
+ActiveRecord::Base.send(:include, Cms::Acts::ContentBlock)
+require 'cms/behaviors'

data/lib/cms/acts/content_block.rb

@@ -0,0 +1,31 @@
+module Cms
+  module Acts
+    module ContentBlock
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods
+        def acts_as_content_block(options={})
+          belongs_to_attachment(options[:belongs_to_attachment].is_a?(Hash) ? options[:belongs_to_attachment] : {}) if options[:belongs_to_attachment]
+          is_archivable(options[:archiveable].is_a?(Hash) ? options[:archiveable] : {}) unless options[:archiveable] == false
+          is_connectable(options[:connectable].is_a?(Hash) ? options[:connectable] : {}) unless options[:connectable] == false
+          flush_cache_on_change(options[:flush_cache_on_change].is_a?(Hash) ? options[:flush_cache_on_change] : {}) unless options[:flush_cache_on_change] == false
+          is_renderable({:instance_variable_name_for_view => "@content_block"}.merge(options[:renderable].is_a?(Hash) ? options[:renderable] : {})) unless options[:renderable] == false
+          is_publishable(options[:publishable].is_a?(Hash) ? options[:publishable] : {}) unless options[:publishable] == false
+          is_searchable(options[:searchable].is_a?(Hash) ? options[:searchable] : {}) unless options[:searchable] == false
+          uses_soft_delete(options[:soft_delete].is_a?(Hash) ? options[:soft_delete] : {}) unless options[:soft_delete] == false
+          is_taggable(options[:taggable].is_a?(Hash) ? options[:taggable] : {}) if options[:taggable]
+          is_userstamped(options[:userstamped].is_a?(Hash) ? options[:userstamped] : {}) unless options[:userstamped] == false  
+          is_versioned(options[:versioned].is_a?(Hash) ? options[:versioned] : {}) unless options[:versioned] == false
+        
+          include InstanceMethods
+        end
+        module InstanceMethods
+          def to_s
+            "#{self.class.name.titleize} '#{name}'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cms/acts/content_page.rb

@@ -0,0 +1,69 @@
+#
+# Can be included into Controllers in your project to allow them to act as though they are CMS pages.
+# This means they can be:
+#
+#   1. Marked as having requiring permission as though they were in a particular section.
+#   2. Handle errors thrown from within the methods in the same way that CMS Pages do.
+#   3. Use CMS page templates as layouts (like TemplateSupport)
+#
+# This is intend to replace and deprecate TemplateSupport (which will be supported for a while for backwards compatibility)
+#
+# Minor Issue:
+#   Error handling for Page not found behaves slightly differently than ContentController currently. If the user is logged
+#   in as an editor, they will get a 500 page rather than 404. This would require reworking how the error processing
+#   works in Cms::ContentRenderingSupport. 
+module Cms
+  module Acts
+
+
+    module ContentPage
+
+      def self.included(base)
+        base.send :include, Cms::ContentRenderingSupport
+        base.send :include, Cms::Authentication::Controller
+        base.extend ClassMethods
+
+        base.helper Cms::PageHelper
+        base.helper Cms::RenderingHelper
+        base.helper Cms::MenuHelper
+      end
+
+      # Before filter that determines if the current user can access a specific section.
+      def check_access_to_section
+        user = current_user
+        logger.warn "Checking that current_user '#{user.login}' has access to view section with path '#{self.class.in_section}'."
+        unless user.able_to_view?(self.class.in_section)
+          store_location
+          raise Cms::Errors::AccessDenied
+        end
+      end
+
+      module ClassMethods
+
+        # Requires that some or all of the actions on this controller require the same permissions as a specific section of the website.
+        # Note that section paths aren't currently unique so the 'first' section found will be looked at.
+        #
+        # Params:
+        #   path - Should match the 'path' attribute for a given section.
+        #   options - Hash of options that will be passed to the before_filter call. See before_filter for valid options.
+        #
+        # Example:
+        #   MyController < ApplicationController
+        #     include Cms::Acts::ContentPage
+        #     requires_permission_for_section "/somepath", :except=>"action_name"
+        #   ...
+        #
+        def requires_permission_for_section(path, options={})
+          logger.warn "Setting path #{path}"
+          @section_path = path
+          before_filter :check_access_to_section, options
+        end
+
+        def in_section
+          @section_path
+        end
+      end
+    end
+
+  end
+end

data/lib/cms/authentication/controller.rb

@@ -0,0 +1,214 @@
+#
+# Defines the authentication behavior for controllers in BrowserCMS. It can be added to any controller that needs to 
+# hook into the BrowserCMS Authentication behavior like so:
+#
+# class MySuperSecureController < ApplicationController
+#   include Cms::Authentication::Controller
+#
+# It is based off Restful_Authentication, and adds in behavior to deal with several concepts specific to BrowserCMS.
+#
+# (Note: 10/8/09 - I was comparing this to a very old version of the generated code from Restful_Authentication,
+# so some of the following items may be 'stock' to that. (Especially #2)
+#
+# 1. Guests - These represents users that are not logged in. What guests can see and do can be modified via the CMS UI. Guests
+#             are not considered to be 'logged in'.
+# 2. 'Current' User - The currently logged in user is stored in a thread local, and can be accessed anywhere via 'User.current'.
+#             This allows model code to easily record which user is making changes to records, for versioning, etc.
+#
+# 3. 'Admin' Access Denied Page - If users try to access a protected controller, they are redirected to the CMS administration Login page
+#             which may be different than the 'front end' user login page. (Cms::Controller handles that differently)
+#
+#
+# To Dos: It appears as though we are storing the 'current' user in two places, @current_user and User.current. This is probably not DRY, but
+#   more testing would be needed.
+#
+module Cms
+  module Authentication
+    module Controller
+      protected
+        # Returns true or false if the user is logged in.
+        # Preloads User.current with the user model if they're logged in.
+        def logged_in?
+          !current_user.nil? && !current_user.guest?
+        end
+
+        # Accesses the current user from the session or 'remember me' cookie.
+        # If the user is not logged in, this will be set to the guest user, which represents a public
+        # user, who will likely have more limited permissions
+        def current_user
+          # Note: We have disabled basic_http_auth
+          @current_user ||= begin
+            User.current = (login_from_session || login_from_cookie || User.guest)  
+          end
+        end
+
+        # Store the given user id in the session.
+        def current_user=(new_user)
+          session[:user_id] = new_user ? new_user.id : nil
+          @current_user = new_user || false
+          User.current = @current_user
+        end
+
+        # Check if the user is authorized
+        #
+        # Override this method in your controllers if you want to restrict access
+        # to only a few actions or if you want to check if the user
+        # has the correct rights.
+        #
+        # Example:
+        #
+        #  # only allow nonbobs
+        #  def authorized?
+        #    current_user.login != "bob"
+        #  end
+        #
+        def authorized?(action=nil, resource=nil, *args)
+          logged_in?
+        end
+
+        # Filter method to enforce a login requirement.
+        #
+        # To require logins for all actions, use this in your controllers:
+        #
+        #   before_filter :login_required
+        #
+        # To require logins for specific actions, use this in your controllers:
+        #
+        #   before_filter :login_required, :only => [ :edit, :update ]
+        #
+        # To skip this in a subclassed controller:
+        #
+        #   skip_before_filter :login_required
+        #
+        def login_required
+          authorized? || access_denied
+        end
+
+        # Redirect as appropriate when an access request fails.
+        #
+        # The default action is to redirect to the BrowserCMS admin login screen.
+        #
+        # Override this method in your controllers if you want to have special
+        # behavior in case the user is not authorized
+        # to access the requested action.  For example, a popup window might
+        # simply close itself.
+        def access_denied
+          respond_to do |format|
+            format.html do
+              store_location
+              redirect_to cms_login_path
+            end
+          end
+        end
+
+        # Store the URI of the current request in the session.
+        #
+        # We can return to this location by calling #redirect_back_or_default.
+        def store_location
+          session[:return_to] = request.request_uri
+        end
+
+        # Redirect to the URI stored by the most recent store_location call or
+        # to the passed default.  Set an appropriately modified
+        #   after_filter :store_location, :only => [:index, :new, :show, :edit]
+        # for any controller you want to be bounce-backable.
+        def redirect_back_or_default(default)
+          redirect_to(session[:return_to] || default)
+          session[:return_to] = nil
+        end
+
+        # Inclusion hook to make #current_user and #logged_in?
+        # available as ActionView helper methods.
+        def self.included(base)
+          base.send :helper_method, :current_user, :logged_in?, :authorized? if base.respond_to? :helper_method
+        end
+
+        #
+        # Login
+        #
+
+        # Called from #current_user.  First attempt to login by the user id stored in the session.
+        def login_from_session
+          self.current_user = User.find_by_id(session[:user_id]) if session[:user_id]
+        end
+
+        # Called from #current_user.  Now, attempt to login by basic authentication information.
+        def login_from_basic_auth
+          authenticate_with_http_basic do |login, password|
+            self.current_user = User.authenticate(login, password)
+          end
+        end
+    
+        #
+        # Logout
+        #
+
+        # Called from #current_user.  Finaly, attempt to login by an expiring token in the cookie.
+        # for the paranoid: we _should_ be storing user_token = hash(cookie_token, request IP)
+        def login_from_cookie
+          user = cookies[:auth_token] && User.find_by_remember_token(cookies[:auth_token])
+          if user && user.remember_token?
+            self.current_user = user
+            handle_remember_cookie! false # freshen cookie token (keeping date)
+            self.current_user
+          end
+        end
+
+        # This is ususally what you want; resetting the session willy-nilly wreaks
+        # havoc with forgery protection, and is only strictly necessary on login.
+        # However, **all session state variables should be unset here**.
+        def logout_keeping_session!
+          # Kill server-side auth cookie
+          User.current.forget_me if User.current.is_a? User
+          User.current = false     # not logged in, and don't do it for me
+          kill_remember_cookie!     # Kill client-side auth cookie
+          session[:user_id] = nil   # keeps the session but kill our variable
+          # explicitly kill any other session variables you set
+        end
+
+        # The session should only be reset at the tail end of a form POST --
+        # otherwise the request forgery protection fails. It's only really necessary
+        # when you cross quarantine (logged-out to logged-in).
+        def logout_killing_session!
+          logout_keeping_session!
+          reset_session
+        end
+    
+        #
+        # Remember_me Tokens
+        #
+        # Cookies shouldn't be allowed to persist past their freshness date,
+        # and they should be changed at each login
+
+        # Cookies shouldn't be allowed to persist past their freshness date,
+        # and they should be changed at each login
+        def valid_remember_cookie?
+          return nil unless User.current
+          (User.current.remember_token?) && 
+            (cookies[:auth_token] == User.current.remember_token)
+        end
+    
+        # Refresh the cookie auth token if it exists, create it otherwise
+        def handle_remember_cookie! new_cookie_flag
+          return unless User.current
+          case
+          when valid_remember_cookie? then User.current.refresh_token # keeping same expiry date
+          when new_cookie_flag        then User.current.remember_me 
+          else                             User.current.forget_me
+          end
+          send_remember_cookie!
+        end
+  
+        def kill_remember_cookie!
+          cookies.delete :auth_token
+        end
+    
+        def send_remember_cookie!
+          cookies[:auth_token] = {
+            :value   => User.current.remember_token,
+            :expires => User.current.remember_token_expires_at }
+        end
+
+    end
+  end
+end

data/lib/cms/authentication/model.rb

@@ -0,0 +1,116 @@
+module Cms
+  module Authentication
+    module Model
+      def self.included(model_class)
+        model_class.extend ClassMethods
+        model_class.class_eval do
+          include InstanceMethods
+        
+          # Virtual attribute for the unencrypted password
+          attr_accessor :password
+          validates_presence_of     :password,                   :if => :password_required?
+          validates_presence_of     :password_confirmation,      :if => :password_required?
+          validates_confirmation_of :password,                   :if => :password_required?
+          #validates_length_of       :password, :within => 6..40, :if => :password_required?
+          before_save :encrypt_password
+        end      
+      end
+
+      module ClassMethods
+        def authenticate(login, password)
+          u = find_by_login(login) # need to get the salt
+          u && u.authenticated?(password) && !u.expired? ? u : nil
+        end
+
+        #Method to make it easy to change a user's password from the console, not used in the app
+        def change_password(login, new_password)
+          find_by_login(login).change_password(new_password)
+        end
+
+        def make_token
+          secure_digest(Time.now, (1..10).map{ rand.to_s })
+        end
+
+        def password_digest(password, salt)
+          key = '8771d0d9bef6f1091b723d2e701a17c811d69b26'
+          digest = key
+          10.times do
+            digest = secure_digest(digest, salt, password, key)
+          end
+          digest
+        end      
+      
+        def secure_digest(*args)
+          Digest::SHA1.hexdigest(args.flatten.join('--'))
+        end      
+      
+      end
+    
+      module InstanceMethods
+        #Method to make it easy to change a user's password from the console, not used in the app
+        def change_password(new_password)
+          update_attributes(:password => new_password, :password_confirmation => new_password)
+        end      
+      
+        # Encrypts the password with the user salt
+        def encrypt(password)
+          self.class.password_digest(password, salt)
+        end
+      
+        def authenticated?(password)
+          crypted_password == encrypt(password)
+        end
+      
+        # before filter 
+        def encrypt_password
+          return if password.blank?
+          self.salt = self.class.make_token if new_record?
+          self.crypted_password = encrypt(password)
+        end
+      
+        def password_required?
+          crypted_password.blank? || !password.blank?
+        end      
+      
+        def remember_token?
+          (!remember_token.blank?) && 
+            remember_token_expires_at && (Time.now.utc < remember_token_expires_at.utc)
+        end
+
+        # These create and unset the fields required for remembering users between browser closes
+        def remember_me
+          remember_me_for 2.weeks
+        end
+
+        def remember_me_for(time)
+          remember_me_until time.from_now.utc
+        end
+
+        def remember_me_until(time)
+          self.remember_token_expires_at = time
+          self.remember_token            = self.class.make_token
+          save
+        end
+
+        # refresh token (keeping same expires_at) if it exists
+        def refresh_token
+          if remember_token?
+            self.remember_token = self.class.make_token 
+            save      
+          end
+        end
+
+        # 
+        # Deletes the server-side record of the authentication token.  The
+        # client-side (browser cookie) and server-side (this remember_token) must
+        # always be deleted together.
+        #
+        def forget_me
+          self.remember_token_expires_at = nil
+          self.remember_token            = nil
+          save
+        end      
+      end
+    end
+  end
+end