browsercms-artirix 4.0.0.rc1.art4

data/app/models/cms/page_partial.rb

@@ -0,0 +1,40 @@
+module Cms
+  class PagePartial < Cms::DynamicView
+
+    before_validation :prepend_underscore
+
+    validates_format_of :name, :with => /\A_[a-z]+[a-z0-9_]*\Z/, :message => "can only contain lowercase letters, numbers and underscores and must begin with an underscore"
+
+    def self.relative_path
+      "partials"
+    end
+
+    def file_path
+      File.join(self.class.base_path, "partials", file_name)
+    end
+
+    def self.display_name(file_name)
+      name, format, handler = file_name.split('.')
+      "#{name.sub(/^_/, '').titleize} (#{format}/#{handler})"
+    end
+
+    def prepend_underscore
+      if !name.blank? && name[0, 1] != '_'
+        self.name = "_#{name}"
+      end
+    end
+
+    def partial?
+      true
+    end
+
+    def placeholder
+      "_header"
+    end
+
+    # Generates hint for editing
+    def hint
+      "No spaces allowed. Must start with _."
+    end
+  end
+end

data/app/models/cms/page_route.rb

@@ -0,0 +1,140 @@
+# Allows Rails routes to be matched to CMS pages, allowing arbitrary code that can be executed before the page is rendered.
+#
+# The primary goal of this is to provide human readable (and cachable) URLs for content_blocks. For example,
+# a single 'Article' page can have a portlet that knows how to look up and display an Article by id. By default, this
+# would look like this:
+#   GET /article?id=120
+#
+# Unless the Article page is marked a 'cache enabled = false' this will cause problems. Plus that URL is ugly.
+# With PageRoutes, you can have multiple URLs all map to the article page, like so:
+#   GET /article/2010/12/30/article-1
+#   GET /article/2011/1/18/article-2
+# In both these cases, these URLs can be matched to a Rails Route which is linked to a page:
+# GET /article/:year/:month/:day/:slug -> Articles Page
+#
+# Saving a new PageRoute will reload the Rails routes.
+#
+class Cms::PageRoute < ActiveRecord::Base
+
+
+  belongs_to :page, :class_name => 'Cms::Page'
+  has_many :conditions, :class_name => 'Cms::PageRouteCondition'
+  has_many :requirements, :class_name => 'Cms::PageRouteRequirement'
+
+  extend Cms::DefaultAccessible
+  
+  validates_presence_of :pattern, :page_id
+  validates_uniqueness_of :pattern
+
+  after_save :reload_routes
+
+
+  # Determines if its safe to call any persistent methods on PageRoutes. This can be false if either the database doesn't exist,
+  # or the page_routes table doesn't yet exist.
+  #
+  # @return [Boolean] Whether its safe to call any ActiveRecord persistent method or not.
+  def self.can_be_loaded?
+    database_exists? && table_exists?
+  end
+
+  # Force Rails to reload the routes. Allows modules to call this without concern that the Rails classes are going to change again.
+  def self.reload_routes
+    Rails.application.reload_routes!
+  end
+
+  def reload_routes
+    Cms::PageRoute.reload_routes
+  end
+
+  def add_condition(name, value)
+    conditions.build(:name => name.to_s, :value => value.to_s)
+  end
+
+  # @deprecated Use add_constraint instead (matches Rails 3 syntax)
+  def add_requirement(name, value)
+    requirements.build(:name => name.to_s, :value => value.to_s)
+  end
+
+  alias_method :add_constraint, :add_requirement
+
+  # @deprecated Rails 3 no longer uses a 'conditions' element in its syntax for routing.
+  def conditions_map
+    conditions.inject({}) { |acc, e| acc[e.name.to_sym] = e.value.to_sym; acc }
+  end
+
+
+  def requirements_map
+    requirements.inject({}) { |acc, e| acc[e.name.to_sym] = Regexp.new(e.value); acc }
+  end
+
+  def route_name
+    name ? name.to_slug.gsub('-', '_') : nil
+  end
+
+  alias_method :as, :route_name
+
+  def to
+    "cms/content#show_page_route"
+  end
+
+  # @param [Symbol | Array] method A method name (like :get) or array of names (ie. [:get :post]) to constraint this route.
+  def via=(method)
+    if method.respond_to?(:each)
+      method.each do |m|
+        add_condition(:method, m)
+      end
+    else
+      add_condition(:method, method)
+    end
+  end
+
+  # Returns which methods this route can be via. Defaults to [:get, :post] if not specified.
+  def via
+    found = conditions.collect() { |condition|
+      if condition.name.to_sym == :method;
+        condition.value.to_sym
+      end }
+    methods = found.compact
+    if methods.empty?
+      methods << :get << :post
+    end
+    methods
+  end
+
+  # Builds a hash which can be passed to the :constraints value in a route, like:
+  #
+  # match 'some/:pattern', :constraints => page_route.constraints()
+  def constraints
+    requirements_map
+  end
+
+  # This is used in defining the route in the ActionController::Routing
+  # Used in Rails 2 version of routing (No longer valid for rails 3)
+  # @deprecated
+  def options_map
+    m = {:controller => "cms/content", :action => "show_page_route"}
+
+    m[:_page_route_id] = self.id.to_s
+
+    m[:requirements] = requirements_map
+    m[:conditions] = conditions_map
+
+    m
+  end
+
+  def page_route_id
+    self.id.to_s
+  end
+
+  # This is called by an instance of the content controller 
+  # in the process of rendering a page.  This will eval the code
+  # stored in this page route in the context of the controller.  
+  # The main purpose of this method is to set instance variables 
+  # that will be used by one or more portlets when the page is rendered.  
+  # To set an instance variable, the code should contain something like:
+  #    @news_article = NewsArticle.find(params[:id]))
+  def execute(controller)
+    controller.instance_eval(code) unless code.blank?
+  end
+
+end

data/app/models/cms/page_route_condition.rb

@@ -0,0 +1,5 @@
+module Cms
+  class PageRouteCondition < Cms::PageRouteOption
+    extend DefaultAccessible
+  end
+end

data/app/models/cms/page_route_option.rb

@@ -0,0 +1,7 @@
+module Cms
+  class PageRouteOption < ActiveRecord::Base
+    belongs_to :page_route, :class_name => 'Cms::PageRoute'
+
+    extend DefaultAccessible
+  end
+end

data/app/models/cms/page_route_requirement.rb

@@ -0,0 +1,5 @@
+module Cms
+  class PageRouteRequirement < Cms::PageRouteOption
+    extend DefaultAccessible
+  end
+end

data/app/models/cms/page_template.rb

@@ -0,0 +1,45 @@
+module Cms
+  class PageTemplate < Cms::DynamicView
+
+    validates_format_of :name, :with => /\A[a-z]+[a-z0-9_]*\Z/, :message => "can only contain lowercase letters, numbers and underscores and must begin with a lowercase letter"
+
+    def file_path
+      File.join(self.class.file_path, file_name)
+    end
+
+    def self.relative_path
+      File.join("layouts", "templates")
+    end
+
+    def self.file_path
+      File.join(base_path, relative_path)
+    end
+
+    def self.display_name(file_name)
+      name, format, handler = file_name.split('.')
+      content_type = handler ? "#{format}/#{handler}" : "#{format}"
+      "#{name.titleize} (#{content_type})"
+    end
+
+    # This is a combination of file system page templates
+    # and database page templates
+    def self.options
+      file_system_templates = ActionController::Base.view_paths.map { |p| Dir["#{p}/#{relative_path}/*"] }.flatten.map { |f| File.basename(f) }
+      page_templates = file_system_templates + all.map { |t| t.file_name }
+      page_templates.map { |f| [display_name(f), f] }.sort.uniq
+    end
+
+    def partial?
+      false
+    end
+
+    def placeholder
+      "subpage"
+    end
+
+    # Generates hint for editing
+    def hint
+      "No spaces allowed. Must start with lowercase letter."
+    end
+  end
+end

data/app/models/cms/permission.rb

@@ -0,0 +1,17 @@
+module Cms
+  class Permission < ActiveRecord::Base
+
+   #attr_accessible :name, :full_name, :description
+
+    has_many :group_permissions, :class_name => 'Cms::GroupPermission'
+    has_many :groups, :through => :group_permissions, :class_name => 'Cms::Group'
+
+    validates_presence_of :name
+    validates_uniqueness_of :name
+
+    def self.named(name)
+      where(name: name)
+    end
+
+  end
+end

data/app/models/cms/persistent_user.rb

@@ -0,0 +1,223 @@
+module Cms
+
+  # A parent class for users that need to be persisted in the CMS database.
+  class PersistentUser < ActiveRecord::Base
+
+    self.table_name = 'cms_users'
+
+    # Note that Chrome doesn't expire session cookies immediately so test this in other browsers.
+    # http://stackoverflow.com/questions/16817229/issues-with-devise-rememberable
+    devise :database_authenticatable,
+           # Note that Chrome doesn't expire session cookies immediately so test this in other browsers.
+           # http://stackoverflow.com/questions/16817229/issues-with-devise-rememberable
+           :rememberable,
+           :recoverable,  # Needs to be here so forgot password link works.
+           :authentication_keys => [:login]
+
+
+    has_many :user_group_memberships, :class_name => 'Cms::UserGroupMembership', foreign_key: :user_id
+    has_many :groups, :through => :user_group_memberships, :class_name => 'Cms::Group', foreign_key: :user_id
+    has_many :tasks, :foreign_key => "assigned_to_id", :class_name => 'Cms::Task'
+
+    scope :active, -> { where(["expires_at IS NULL OR expires_at > ?", Time.now.utc]) }
+    extend DefaultAccessible
+
+
+    validates_presence_of :login
+    validates_uniqueness_of :login, :case_sensitive => false
+    validates_format_of :login, :with => /\A\w[\w\.\-_@]+\z/, :message => "use only letters, numbers, and .-_@ please."
+
+    # Class Methods
+    class << self
+
+      def permitted_params
+        super + [{:group_ids => []}]
+      end
+
+      # Returns all users that can :edit_content or :publish_content permissions.
+      #
+      # @return [ActiveRelation<Cms::User>] A scope which will find users with the correct permissions.
+      def able_to_edit_or_publish_content
+        where(["#{Permission.table_name}.name = ? OR #{Permission.table_name}.name = ?", "edit_content", "publish_content"]).includes({:groups => :permissions}).references(:permissions)
+      end
+
+      def current
+        Cms::UsersService.current
+      end
+
+      def current=(user)
+        Cms::UsersService.current = user
+      end
+
+      # Return a GuestUser with the given values.
+      def guest(options = {})
+        Cms::GuestUser.new(options)
+      end
+    end
+
+    # Determines if this user a Guest or not.
+    def guest?
+      !!@guest
+    end
+
+    # checks for usage
+    def cms_user_compatible?
+      true
+    end
+
+    def enable_able?
+      true
+    end
+
+    def disable_able?
+      true
+    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.where(["expires_at is null and id != ?", id]).count > 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
+
+    # Determines if this user should be authenticated. Hook for Devise.
+    #
+    # @override Devise::Models::Authenticatable#active_for_authentication?
+    # @return [Boolean] true if this user has not expired.
+    def active_for_authentication?
+      is_active = !expired?
+      logger.error "Expired User '#{login}' failed to login. Account expired on #{expires_at_formatted}." unless is_active
+      is_active
+    end
+
+    # Determines if this User can have their password changed.
+    def password_changeable?
+      true
+    end
+
+    # Determines if this user has expired or has been disabled.
+    # @return [Boolean]
+    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.where(["#{self.class.table_name}.id = ?", id]).includes({:groups => :users}).references(:users)
+    end
+
+    def viewable_sections
+      @viewable_sections ||= Cms::Section.where(["#{self.class.table_name}.id = ?", id]).includes(:groups => :users).references(:users)
+    end
+
+    def modifiable_sections
+      @modifiable_sections ||= Cms::Section.where(["#{self.class.table_name}.id = ? and #{GroupType.table_name}.cms_access = ?", id, true]).includes(:groups => [:group_type, :users]).references(:users, :groups)
+    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.parent
+      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