browsercms-artirix 4.0.0.rc1.art4

data/app/controllers/cms/sections_controller.rb

@@ -0,0 +1,100 @@
+module Cms
+  class SectionsController < Cms::BaseController
+
+    before_filter :load_parent, :only => [:new, :create]
+    before_filter :load_section, :only => [:edit, :update, :destroy, :move]
+
+    helper_method :public_groups
+    helper_method :cms_groups
+
+    def resource
+      @section
+    end
+
+    def index
+      redirect_to cms.sitemap_path
+    end
+
+    def show
+      redirect_to cms.sitemap_path
+    end
+
+    def new
+      @section = @parent.build_section
+      @section.groups = @parent.groups
+    end
+
+    def create
+      @section = Cms::Section.new(section_params)
+      @section.parent = @parent
+      @section.groups = @section.parent.groups unless current_user.able_to?(:administrate)
+      if @section.save
+        flash[:notice] = "Section '#{@section.name}' was created"
+        redirect_to @section
+      else
+        render :action => 'new'
+      end
+    end
+
+    def edit
+    end
+
+    def update
+      params[:section].delete('group_ids') if params[:section] && !current_user.able_to?(:administrate)
+      @section.attributes = section_params()
+      if @section.save
+        flash[:notice] = "Section '#{@section.name}' was updated"
+        redirect_to @section
+      else
+        render :action => 'edit'
+      end
+    end
+
+    def destroy
+      respond_to do |format|
+        if @section.deletable? && @section.destroy
+          message = "Section '#{@section.name}' was deleted."
+          format.html { flash[:notice] = message; redirect_to(sitemap_url) }
+          format.json { render :json => {:success => true, :message => message} }
+        else
+          message = "Section '#{@section.name}' could not be deleted"
+          format.html { flash[:error] = message; redirect_to(sitemap_url) }
+          format.json { render :json => {:success => false, :message => message} }
+        end
+      end
+    end
+
+    def move
+      if params[:section_id]
+        @move_to = Section.find(params[:section_id])
+      else
+        @move_to = Section.root.first
+      end
+    end
+
+    protected
+
+    def section_params
+      params.require(:section).permit(Cms::Section.permitted_params)
+    end
+
+    def load_parent
+      @parent = Cms::Section.find(params[:section_id])
+      raise Cms::Errors::AccessDenied unless current_user.able_to_edit?(@parent)
+    end
+
+    def load_section
+      @section = Cms::Section.find(params[:id])
+      raise Cms::Errors::AccessDenied unless current_user.able_to_edit?(@section)
+    end
+
+    def public_groups
+      @public_groups ||= Cms::Group.public.order("#{Cms::Group.table_name}.name")
+    end
+
+    def cms_groups
+      @cms_groups ||= Cms::Group.cms_access.order( "#{Cms::Group.table_name}.name")
+    end
+
+  end
+end

data/app/controllers/cms/sessions_controller.rb

@@ -0,0 +1,15 @@
+module Cms
+  # Handles the login/logout function of the site.
+  class SessionsController < Devise::SessionsController
+    include Cms::AdminController
+    before_filter :redirect_to_cms_site, :only => [:new]
+
+    layout 'cms/application'
+
+    def new
+      use_page_title 'Login'
+      super
+    end
+
+  end
+end

data/app/controllers/cms/sites/passwords_controller.rb

@@ -0,0 +1,32 @@
+module Cms
+  module Sites
+    class PasswordsController < Devise::PasswordsController
+      include Cms::ContentPage
+      helper AuthenticationHelper
+
+      template :default
+
+      def new
+        use_page_title('Forgot Password')
+        super
+      end
+
+      def create
+        use_page_title('Forgot Password')
+        super
+      end
+
+      def edit
+        use_page_title('Reset Password')
+        super
+      end
+
+      protected
+
+      # @override [Devise::PasswordsController]
+      def after_sending_reset_password_instructions_path_for(resource_name)
+        main_app.new_cms_user_session_path
+      end
+    end
+  end
+end

data/app/controllers/cms/sites/sessions_controller.rb

@@ -0,0 +1,20 @@
+module Cms
+  module Sites
+
+    # Handles Sign In/Out for public site.
+    class SessionsController < Devise::SessionsController
+      include Cms::ContentPage
+      helper AuthenticationHelper
+      helper UiElementsHelper
+
+      template :default
+
+      def new
+        use_page_title 'Login'
+        super
+      end
+
+
+    end
+  end
+end

data/app/controllers/cms/tags_controller.rb

@@ -0,0 +1,16 @@
+module Cms
+  class TagsController < Cms::ContentBlockController
+    def index
+      load_blocks
+      respond_to do |format|
+        format.html
+        format.json { render :inline => @blocks.map { |e| e.name }.to_json }
+      end
+    end
+
+    def show
+      redirect_to tags_path
+    end
+
+  end
+end

data/app/controllers/cms/tasks_controller.rb

@@ -0,0 +1,56 @@
+module Cms
+  class TasksController < Cms::BaseController
+
+    before_filter :load_page, :only => [:new, :create]
+
+    def new
+      @task = @page.tasks.build(:assigned_by => current_user)
+    end
+
+    def create
+      @task = @page.tasks.build(task_params())
+      @task.assigned_by = current_user
+      if @task.save
+        flash[:notice] = "Page was assigned to '#{@task.assigned_to.login}'"
+        redirect_to @page.path
+      else
+        render :action => 'new'
+      end
+    end
+
+    def complete
+      if params[:task_ids]
+        Task.where(["id in (?)", params[:task_ids]]).each do |t|
+          if t.assigned_to == current_user
+            t.mark_as_complete!
+          end
+        end
+        flash[:notice] = "Tasks marked as complete"
+        redirect_to dashboard_path
+      else
+        @task = Task.find(params[:id])
+        if @task.assigned_to == current_user
+          if @task.mark_as_complete!
+            flash[:notice] = "Task was marked as complete"
+          end
+        else
+          flash[:error] = "You cannot complete tasks that are not assigned to you"
+        end
+        redirect_to @task.page.path
+      end
+    rescue ActiveRecord::RecordNotFound
+      flash[:error] = "No tasks were marked for completion"
+      redirect_to dashboard_path
+    end
+
+    private
+    def task_params
+      params.require(:task).permit(Cms::Task.permitted_params)
+    end
+
+    def load_page
+      @page = Page.find(params[:page_id])
+    end
+
+  end
+end

data/app/controllers/cms/toolbar_controller.rb

@@ -0,0 +1,18 @@
+module Cms
+  class ToolbarController < Cms::BaseController
+
+    layout "cms/toolbar"
+
+    helper Cms::MobileHelper
+
+    def index      
+      if params[:page_toolbar] != "0"
+        @mode = params[:mode]
+        @page_toolbar_enabled = true
+      end
+      @page_version = params[:page_version]
+      @page = Page.find(params[:page_id]).as_of_version(params[:page_version]) if params[:page_id]
+    end
+
+  end
+end

data/app/controllers/cms/user_controller.rb

@@ -0,0 +1,8 @@
+module Cms
+  class UserController < Cms::ApplicationController
+    # Return information about the current user as json. Can be used by cached html pages do create interactive elements.
+    def show
+      render json: Cms::UserPresenter.new(current_user)
+    end
+  end
+end

data/app/controllers/cms/users_controller.rb

@@ -0,0 +1,125 @@
+module Cms
+  class UsersController < Cms::ResourceController
+    include Cms::AdminTab
+
+    check_permissions :administrate, :except => [:change_password, :update_password]
+    before_filter :only_self_or_administrator, :only => [:change_password, :update_password]
+    after_filter :update_flash, :only => [:update]
+
+
+    def index
+      @have_external_users = Cms::ExternalUser.count > 0
+
+      query, conditions = [], []
+
+      unless params[:show_expired]
+        query << "expires_at IS NULL OR expires_at >= ?"
+        conditions << Time.now.utc
+      end
+
+      unless params[:key_word].blank?
+        query << %w(login email first_name last_name).collect { |f| "lower(#{f}) LIKE lower(?)" }.join(" OR ")
+        4.times { conditions << "%#{params[:key_word]}%" }
+      end
+
+      unless params[:group_id].to_i == 0
+        query << "#{UserGroupMembership.table_name}.group_id = ?"
+        conditions << params[:group_id]
+      end
+
+      query.collect! { |q| "(#{q})" }
+      conditions = conditions.unshift(query.join(" AND "))
+      per_page = params[:per_page] || 10
+
+      page_num = params[:page] ? params[:page].to_i : 1
+      @users = PersistentUser.where(conditions).paginate(page: page_num, per_page: per_page).includes(:user_group_memberships).references(:user_group_memberships).order("first_name, last_name, email")
+    end
+
+    def new
+      @user = Cms::User.new
+    end
+
+    def create
+      @user = Cms::User.new(cms_user_params)
+      if @user.save
+        flash[:notice] = "User '#{@user.login}' was created"
+        redirect_to users_path
+      else
+        render :action => 'new'
+      end
+    end
+
+    def change_password
+      user
+    end
+
+    def update_password
+      if user.update(cms_user_params)
+        flash[:notice] = "Password for '#{user.login}' was changed"
+        redirect_to(current_user.able_to?(:administrate) ? users_path : "/")
+      else
+        render :action => 'change_password'
+      end
+    end
+
+    def disable
+      begin
+        user.disable!
+        flash[:notice] = "User #{user.login} disabled"
+      rescue Exception => e
+        flash[:error] = e.message
+      end
+      redirect_to users_path
+    end
+
+    def enable
+      user.enable!
+      redirect_to users_path
+    end
+
+    protected
+
+    def cms_user_params
+      params.require("user").permit(Cms::User.permitted_params)
+    end
+
+    def after_create_url
+      users_path
+    end
+
+    def after_update_url
+      users_path
+    end
+
+    def update_flash
+      if params[:on_fail_action] == "change_password"
+        flash[:notice] = "Password for '#{@object.login}' changed"
+      elsif params[:action] == "create"
+        flash[:notice] = "User '#{@object.login}' was created"
+      else
+        flash[:notice] = "User '#{@object.login}' was updated"
+      end
+    end
+
+    def resource_name
+      'PersistentUser'
+    end
+
+    def variable_name
+      'user'
+    end
+
+    private
+    def user
+      @user ||= PersistentUser.find(params[:id])
+    end
+
+    def set_menu_section
+      @menu_section = 'users'
+    end
+
+    def only_self_or_administrator
+      raise Cms::Errors::AccessDenied if !current_user.able_to?(:administrate) && params[:id].to_i != current_user.id
+    end
+  end
+end

data/app/controllers/tests/pretend_controller.rb

@@ -0,0 +1,32 @@
+# This class exists to provide a test for including page behavior in controllers.
+# I didn't know of a way to add functional tests for controllers/routes that aren't in
+# the apps directory.
+#
+# This should be moved to the test directory if possible.
+class Tests::PretendController < ApplicationController
+  include Cms::Acts::ContentPage
+  
+  requires_permission_for_section "/members", :only=>[:restricted]
+
+  RESTRICTED_H1 = "Restricted"
+
+  def restricted
+    render :text =>"<h1>#{RESTRICTED_H1}</h1> You can see this restricted page."
+  end
+
+  def open
+    render :text =>"<h1>Open Page</h1> You can see this public page."   
+  end
+
+  def error
+    raise StandardError     
+  end
+
+  def not_found
+    raise ActiveRecord::RecordNotFound.new("This thing was missing!")
+  end
+
+  def open_with_layout
+    render :layout=>"templates/subpage"
+  end
+end

data/app/helpers/cms/application_helper.rb

@@ -0,0 +1,258 @@
+# Methods added to this helper will be available to all templates in the cms.
+module Cms
+  module ApplicationHelper
+
+    # Generate the proper link to Preview a Page or Addressable content block (based on type)
+    def preview_content_path(content)
+      if content.class == Cms::Page
+        cms.preview_page_path(content)
+      else
+        content.path
+      end
+    end
+
+    # Help with deprecations messages
+    # @deprecated
+    def cms_handler_path(*args)
+      raise "The #cms_handler_path helper method has been removed from BrowserCMS. Use '#handler_path instead'."
+    end
+
+    def searchable_sections(selected = nil)
+      root = Section.root.first
+      options = [['All sections', 'all'], [root.name, root.id]]
+      root.master_section_list.each { |s| options << [s.full_path, s.id] }
+      options_for_select(options, selected.to_i)
+    end
+
+    def select_per_page
+      options = [10, 20, 50, 100].collect { |c| ["#{c} per page", c] }
+      select_tag("per_page", options_for_select(options, params[:per_page].to_i))
+    end
+
+    def page_versions(page)
+      text = select_tag(:version,
+                        options_for_select(page.versions.all(:order => "version desc").map { |r|
+                          ["v#{r.version}: #{r.version_comment} by #{r.updated_by.login} at #{time_on_date(r.updated_at)}", r.version]
+                        }, page.version),
+                        :onchange => 'this.form.submit(); return false')
+      text << javascript_tag("$('version').selectedIndex = 0") if page.live?
+      text
+    end
+
+    # Generate HTML for draft icon for content that are in draft
+    # @param [Object] content
+    # @param [Object] options
+    # @option options [Boolean] :force (false) If we should force show :publish icon. In many cases, its the 'default' so it doesn't make sense to show.
+    # @return [String] HTML (HTML safe)
+    def draft_icon_tag(content, options={})
+      if content.respond_to?(:draft?) && content.draft?
+        '<span class="draft">Draft</span>'.html_safe
+      elsif options[:force]
+        '<span class="published">Published</span>'.html_safe
+      end
+    end
+
+    def action_icon_src(name)
+      "cms/icons/actions/#{name}.png"
+    end
+
+    def action_icon(name, options={})
+      image_tag action_icon_src(name), {:alt => name.to_s.titleize}.merge(options)
+    end
+
+    def status_icon(status, options={})
+      image_tag "cms/icons/status/#{status.to_s.underscore}.gif", {:alt => status.to_s.titleize}.merge(options)
+    end
+
+    def time_on_date(time)
+      time && "#{time.strftime("%l:%M %p")} on #{time.strftime("%b %e, %Y")}"
+    end
+
+    def format_date(time)
+      time && "#{time.strftime("%b %e, %Y")}"
+    end
+
+    # Renders two links that will check/uncheck a set of checkboxes.
+    #
+    # @param [String] selector The CSS selector for the checkboxes that should be mass checked/unchecked.
+    def check_uncheck_tag(selector)
+      check_id = to_id(selector, "check")
+      uncheck_id = to_id(selector, "uncheck")
+      content_for :html_head do
+        html = <<HTML
+jQuery(function($) {
+  $('a##{check_id}').click(function() {
+    $('#{selector}').prop('checked', true);
+  });
+
+  $('a##{uncheck_id}').click(function() {
+    $('#{selector}').prop('checked', false);
+  });
+})
+HTML
+        javascript_tag html
+      end
+
+      "#{link_to "Check All", '#', :id => check_id}, #{link_to "Uncheck All", '#', :id => uncheck_id}".html_safe
+    end
+
+    # @deprecated Use check_uncheck_tag instead. Retained for backwards compatibility w/ CMS implementations.
+    def link_to_check_all(selector, name="Check All")
+      id = to_id(selector, "check")
+      content_for :html_head do
+        html = <<HTML
+jQuery(function($) {
+  $('a##{id}').click(function() {
+    $('#{selector}').attr('checked', true);
+  });
+})
+HTML
+        javascript_tag html
+      end
+      link_to name, '#', :id => id
+    end
+
+    # @deprecated Use check_uncheck_tag instead. Retained for backwards compatibility w/ CMS implementations.
+    def link_to_uncheck_all(selector, name="Uncheck All")
+      id = to_id(selector, "uncheck")
+      content_for :html_head do
+        html = <<HTML
+jQuery(function($) {
+  $('a##{id}').click(function() {
+    $('#{selector}').attr('checked', false);
+  });
+})
+HTML
+        javascript_tag html
+      end
+      link_to name, '#', :id => id
+    end
+
+    def span_tag(content)
+      content_tag :span, content
+    end
+
+
+
+    def dk_button_wrapper(content)
+      (content).gsub("lt_button_", "dk_button_")
+    end
+
+    def group_ids
+      (params[:group_ids] || @user.group_ids).collect { |g| g.to_i }
+    end
+
+    def group_filter
+      select_tag("group_id",
+                 options_from_collection_for_select(Group.all.to_a.insert(0, Group.new(:id => nil, :name => "Show All Groups")),
+                                                    "id",
+                                                    "name",
+                                                    params[:group_id].to_i),
+                class: 'group_filter'
+      )
+    end
+
+    # Fetches a list of categories for a cms_drop_down. Will prompt users to create Categories/Categories types if
+    # the proper ones don't exist.
+    #
+    # @deprecated Use <%= f.association :categories %> instead.
+    def categories_for(category_type_name, order="name")
+      cat_type = CategoryType.named(category_type_name).first
+      categories = cat_type ? cat_type.category_list(order) : [Category.new(:name => "-- You must first create a 'Category Type' named '#{category_type_name}'")]
+      categories.empty? ? [Category.new(:name => "-- You must first create a Category with a Category Type of '#{category_type_name}'.")] : categories
+    end
+
+    # Generates the HTML to render a paging control, if there is more than one page to be shown.
+    #
+    # @param [Array] collection List of content to be shown
+    # @param [Cms::ContentType || Class] content_type The content type of the collection (used to generate links to Previous/Next)
+    # @param [Hash] options
+    def render_pagination(collection, content_type, options={})
+      return content_tag(:div, 'No Content', :class => 'pagination') if collection.blank?
+
+      paths_options = {
+        first_page_path:    { page: 1 },
+        previous_page_path: { page: collection.previous_page || 1 },
+        current_page_path:  {},
+        next_page_path:     { page: collection.next_page || collection.current_page },
+        last_page_path:     { page: collection.total_pages },
+      }
+
+      locals = {
+        collection:   collection,
+        content_type: content_type,
+      }
+
+      path_for_content_type = build_path_for(content_type)
+
+      paths_options.each do |key, path_options|
+        locals[key] = engine(content_type).polymorphic_path(path_for_content_type, path_options.merge(options))
+      end
+
+      render partial: 'pagination', locals: locals
+    end
+
+    def url_with_mode(url, mode)
+      url = "" unless url # Handles cases where request.referrer is nil (see cms/_page_toolbar.html.erb for an example)
+      uri = URI.parse(url)
+      if uri.query =~ /mode=[^&]*/
+        "#{uri.path}?#{uri.query.gsub(/((^|&)mode=)[^&]*/) { |s| "#{$1}#{mode}" }}"
+      elsif uri.query
+        "#{uri.path}?#{uri.query}&mode=#{mode}"
+      else
+        "#{uri.path}?mode=#{mode}"
+      end
+    end
+
+    def determine_order(current_order, order)
+      if current_order == order
+        if order =~ / desc$/i
+          order.sub(/ desc$/i, '')
+        else
+          order << ' desc'
+        end
+      else
+        order
+      end
+    end
+
+    # Render a CMS styled 'Edit' button. This button will appear on tool bars, typically set apart visually from other buttons.
+    # @deprecated Use link_to
+    # @param [Hash] options The options for this tag
+    # @option options [Path] :path The path or URL to link_to. Takes same types at url_for or link_to. Defaults to '#' if not specified.
+    # @option options [Boolean] :enabled If false, the button will be marked disabled. Default to false.
+    def edit_button(options={bootstrap: false})
+
+      label = options[:bootstrap]? "Edit" : span_tag("&nbsp;Edit&nbsp;".html_safe)
+      classes = styles_for_button(options)
+      classes << " disabled" if !options[:enabled]
+
+      link_to_path = options[:path] ? options[:path] : "#"
+      span_options = {:id => 'edit_button', :class => classes}
+      link_to label, link_to_path, span_options
+
+    end
+
+    # Render a CMS styled 'Add' button. This button will appear on tool bars, typically set apart visually from other buttons.
+    #
+    # @param [Path] The path or URL to link_to. Takes same types at url_for or link_to.
+    def add_button(path, options={bootstrap: false})
+      classes = styles_for_button(options)
+      label = options[:bootstrap]? "Add" : span_tag("&nbsp;Add&nbsp;".html_safe)
+      span_options = {:class => classes}
+      link_to label, path, span_options
+    end
+
+    private
+
+    def styles_for_button(options)
+      options[:bootstrap] ? "btn btn-primary pull-left": "button"
+    end
+    # Converts a CSS jQuery selector into something that can be suitably used as a CSS id element.
+    def to_id(selector, suffix=nil)
+      id = selector.gsub(".", "_")
+      id = id + "_#{suffix}" if suffix
+      id
+    end
+  end
+end