forest_cms 0.98.1

data/app/controllers/admin/block_layouts_controller.rb

@@ -0,0 +1,47 @@
+class Admin::BlockLayoutsController < Admin::ForestController
+  before_action :set_block_layout, only: [:edit, :update]
+
+  def index
+    @block_layouts = apply_scopes(BlockLayout).by_id.page params[:page]
+  end
+
+  def new
+    @block_layout = BlockLayout.new
+    authorize @block_layout
+  end
+
+  def edit
+    authorize @block_layout
+  end
+
+  def create
+    @block_layout = BlockLayout.new(block_layout_params)
+    authorize @block_layout
+
+    if @block_layout.save
+      redirect_to edit_admin_block_layout_path(@block_layout), notice: 'BlockLayout was successfully created.'
+    else
+      render :new
+    end
+  end
+
+  def update
+    authorize @block_layout
+
+    if @block_layout.update(block_layout_params)
+      redirect_to edit_admin_block_layout_path(@block_layout), notice: 'BlockLayout was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  private
+
+    def block_layout_params
+      params.require(:block_layout).permit(:slug, :display_name, :description)
+    end
+
+    def set_block_layout
+      @block_layout = BlockLayout.find(params[:id])
+    end
+end

data/app/controllers/admin/cache_purge_controller.rb

@@ -0,0 +1,11 @@
+class Admin::CachePurgeController < Admin::ForestController
+  def index
+    authorize :dashboard, :index?
+
+    logger.info "[Forest] Performing user-issued cache clear"
+
+    Rails.cache.clear
+
+    redirect_to params.delete(:return_to) || admin_path, notice: "Cache has been cleared."
+  end
+end

data/app/controllers/admin/dashboard_controller.rb

@@ -0,0 +1,6 @@
+class Admin::DashboardController < Admin::ForestController
+  def index
+    authorize :dashboard, :index?
+    @page_title = 'Dashboard'
+  end
+end

data/app/controllers/admin/documentation_controller.rb

@@ -0,0 +1,5 @@
+class Admin::DocumentationController < Admin::ForestController
+  def index
+    authorize :dashboard, :index?
+  end
+end

data/app/controllers/admin/errors_controller.rb

@@ -0,0 +1,9 @@
+class ErrorsController < ForestController
+  def not_found
+    render status: 404
+  end
+
+  def internal_server_error
+    render status: 500
+  end
+end

data/app/controllers/admin/forest_controller.rb

@@ -0,0 +1,96 @@
+class Admin::ForestController < ApplicationController
+  include Pundit
+
+  protect_from_forgery with: :exception, prepend: true
+
+  layout 'admin'
+
+  before_action :authenticate_user!
+  before_action :set_body_classes, :set_page_title
+  before_action :reset_class_method_cache
+  before_action :set_admin_resources
+
+  rescue_from ActiveRecord::InvalidForeignKey, with: :foreign_key_contraint
+  rescue_from ActiveRecord::RecordNotUnique, with: :record_not_unique
+
+  # rescue_from Pundit::NotAuthorizedError, with: :user_not_authorized
+
+  has_scope :by_status
+  has_scope :by_id
+  has_scope :by_title
+  has_scope :by_slug
+  has_scope :by_created_at
+  has_scope :by_updated_at
+  has_scope :by_status
+  has_scope :fuzzy_search
+
+  private
+
+    def set_body_classes
+      controller_heirarchy = self.class.name.split('::').reject(&:blank?)
+      controller_heirarchy.pop if controller_heirarchy.length > 1
+      controller_heirarchy = controller_heirarchy.collect { |a| "controller-class--#{a.underscore}" }.join(' ')
+
+      classes = []
+      classes << controller_heirarchy
+      classes << "controller--#{controller_name}"
+      classes << "action--#{action_name}"
+
+      @body_classes = classes.join ' '
+    end
+
+    def set_page_title
+      @page_title = controller_name.titleize
+    end
+
+    def reset_class_method_cache
+      Menu.reset_method_cache!
+      Setting.reset_method_cache!
+    end
+
+    # def user_not_authorized
+    #   if Rails.env.production?
+    #     redirect_to root_path
+    #   else
+    #     raise Pundit::NotAuthorizedError
+    #   end
+    # end
+
+    def set_admin_resources
+      @admin_resources ||= admin_resource_names.collect do |resource_name|
+        resource_name.sub(/^admin_/, '').classify.safe_constantize
+      end.reject(&:blank?)
+         .reject { |r| r.class == Module }
+    end
+
+    def admin_resource_names
+      @admin_resource_names ||= Rails.application.routes.routes.collect do |route|
+        if route.path.spec.to_s.starts_with?('/admin') && route.requirements[:action] == 'index'
+          route.name
+        end
+      end.reject(&:blank?)
+         .uniq
+         .sort
+    end
+
+    def record
+      instance_variable_get("@#{controller_name.singularize}")
+    end
+
+    def foreign_key_contraint(exception)
+      if record
+        statusable_message = record.try(:statusable?) ? ' Alternatively, you may want to set this record\'s status to hidden instead.' : ''
+        redirect_to edit_polymorphic_path([:admin, record]), flash: { error: ["This record can't be deleted because another record depends on it. First remove the association to the other record before deleting this one.#{statusable_message}", "<code>#{exception.message}</code>"] }
+      else
+        raise
+      end
+    end
+
+    def record_not_unique(exception)
+      if record && record.try(:sluggable?)
+        redirect_to edit_polymorphic_path([:admin, record]), flash: { error: ["A record with this slug already exists. Please create a unique slug.", "<code>#{exception.message}</code>"] }
+      else
+        raise
+      end
+    end
+end

data/app/controllers/admin/imports_controller.rb

@@ -0,0 +1,34 @@
+class Admin::ImportsController < Admin::ForestController
+  before_action :set_import, only: [:edit]
+
+  def edit
+    authorize @import
+
+    respond_to do |format|
+      format.html
+      format.csv {
+        send_data @import.to_csv_template, filename: "#{@import.to_s.parameterize.underscore}-import-template.csv"
+      }
+    end
+  end
+
+  def create
+    klass = params[:import][:model_name].constantize
+    file = params[:import][:file]
+
+    authorize klass
+
+    Import.new(klass, file)
+
+    redirect_to edit_admin_import_path(klass.model_name.singular), notice: "Import has been started and is being processed in the background."
+  end
+
+  private
+
+    def import_params
+    end
+
+    def set_import
+      @import = params[:id].camelcase.constantize
+    end
+end

data/app/controllers/admin/media_items_controller.rb

@@ -0,0 +1,107 @@
+class Admin::MediaItemsController < Admin::ForestController
+  before_action :set_media_item, only: [:show, :edit, :update, :destroy]
+  before_action :set_s3_direct_post, only: [:new, :edit, :create, :update]
+
+  has_scope :by_date
+  has_scope :by_content_type
+  has_scope :videos, type: :boolean
+  has_scope :images, type: :boolean
+  has_scope :pdfs, type: :boolean
+  has_scope :fuzzy_search
+
+  # GET /media_items
+  def index
+    @media_items = apply_scopes(MediaItem.all).by_id.not_hidden.page(params[:page]).per(36)
+    authorize @media_items
+
+    if params[:layout].blank? || params[:layout] != 'list'
+      @layout = :grid
+    else
+      @layout = :list
+    end
+
+    respond_to :html, :json
+  end
+
+  # GET /media_items/1
+  def show
+  end
+
+  # GET /media_items/new
+  def new
+    @media_item = MediaItem.new
+    authorize @media_item
+  end
+
+  # GET /media_items/1/edit
+  def edit
+    authorize @media_item
+  end
+
+  # POST /media_items
+  def create
+    @media_item = MediaItem.new(media_item_params)
+    authorize @media_item
+
+    respond_to do |format|
+      if @media_item.save
+        format.html { redirect_to edit_admin_media_item_path(@media_item), notice: 'Media item was successfully created.' }
+        format.json { render json: { files: [@media_item.to_jq_upload]}, status: :created, location: [:admin, @media_item] }
+      else
+        format.html { render :new }
+        format.json { render json: @media_item.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /media_items/1
+  def update
+    authorize @media_item
+    if @media_item.update(media_item_params)
+      redirect_to edit_admin_media_item_path(@media_item), notice: 'Media item was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  # PATCH/PUT /media_items
+  def update_multiple
+    if params['selected']&.any?
+      @media_items = MediaItem.where(id: params[:selected])
+      authorize @media_items
+      if params[:bulk_actions] == 'delete'
+        @media_items.destroy_all
+        notice = 'Media items were successfully destroyed.'
+      else
+        notice = 'Please select a bulk action.'
+      end
+    else
+      notice = 'Please select a media item.'
+    end
+    redirect_to admin_media_items_url, notice: notice
+  end
+
+  # DELETE /media_items/1
+  def destroy
+    authorize @media_item
+    @media_item.destroy
+    redirect_to admin_media_items_url, notice: 'Media item was successfully destroyed.'
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_media_item
+      @media_item = MediaItem.find(params[:id])
+    end
+
+    # Only allow a trusted parameter "white list" through.
+    def media_item_params
+      params.require(:media_item).permit(:title, :slug, :caption, :alternative_text, :description, :attachment, :selected, :point_of_interest_x, :point_of_interest_y)
+    end
+
+    def set_s3_direct_post
+      if defined? S3_BUCKET
+        @s3_direct_post = S3_BUCKET.presigned_post(key: "uploads/#{SecureRandom.uuid}/${filename}", success_action_status: '201', acl: 'public-read')
+      end
+    end
+end

data/app/controllers/admin/menus_controller.rb

@@ -0,0 +1,69 @@
+class Admin::MenusController < Admin::ForestController
+  before_action :set_menu, only: [:show, :edit, :update, :destroy]
+  before_action :set_pages, only: [:edit, :update, :new]
+
+  # GET /menus
+  def index
+    @menus = apply_scopes(Menu.order(id: :asc)).page(params[:page])
+    authorize @menus
+  end
+
+  # GET /menus/1
+  def show
+  end
+
+  # GET /menus/new
+  def new
+    @menu = Menu.new
+    authorize @menu
+  end
+
+  # GET /menus/1/edit
+  def edit
+    authorize @menu
+  end
+
+  # POST /menus
+  def create
+    @menu = Menu.new(menu_params)
+    authorize @menu
+
+    if @menu.save
+      redirect_to edit_admin_menu_path(@menu), notice: 'Menu was successfully created.'
+    else
+      render :new
+    end
+  end
+
+  # PATCH/PUT /menus/1
+  def update
+    authorize @menu
+    if @menu.update(menu_params)
+      redirect_to edit_admin_menu_path(@menu), notice: 'Menu was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  # DELETE /menus/1
+  def destroy
+    authorize @menu
+    @menu.destroy
+    redirect_to admin_menus_url, notice: 'Menu was successfully destroyed.'
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_menu
+      @menu = Menu.find(params[:id])
+    end
+
+    def set_pages
+      @pages = Page.page(1)
+    end
+
+    # Only allow a trusted parameter "white list" through.
+    def menu_params
+      params.require(:menu).permit(:title, :slug, :structure)
+    end
+end

data/app/controllers/admin/pages_controller.rb

@@ -0,0 +1,105 @@
+class Admin::PagesController < Admin::ForestController
+  before_action :set_page, only: [:show, :edit, :update, :destroy]
+  before_action :set_block_layout, only: [:create, :edit, :new]
+  before_action :set_block_kinds, only: [:create, :edit, :new]
+
+  has_scope :by_parent_page
+  has_scope :title_like
+
+  def index
+    if request.format.json?
+      @pages = apply_scopes(Page).by_title.where.not(id: params[:current_record]).page(params[:page])
+    else
+      # TODO: fuzzy searching doesn't work properly with page hierarchy
+      @parent_pages = apply_scopes(Page.includes(:immediate_children)).parent_pages.page(params[:page])
+      @pages = apply_scopes(Page).by_title.page params[:page]
+    end
+
+    authorize @pages
+    respond_to :html, :json
+  end
+
+  # def show
+  #   unless @page
+  #     raise ActionController::RoutingError.new('Not Found')
+  #   end
+  #   authorize @page
+  #   redirect_to edit_admin_page_path(@page)
+  # end
+
+  def new
+    @page = Page.new
+    authorize @page
+  end
+
+  def edit
+    authorize @page
+  end
+
+  def create
+    @page = Page.new
+    authorize @page
+
+    respond_to do |format|
+      if @page.update(page_params)
+        format.html { redirect_to edit_admin_page_path(@page), notice: 'Page was successfully created.' }
+        format.json { render :show, status: :created, location: @page }
+      else
+        format.html { render :new }
+        format.json { render json: @page.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def update
+    authorize @page
+
+    respond_to do |format|
+      if @page.update(page_params)
+        format.html { redirect_to edit_admin_page_path(@page), notice: 'Page was successfully updated.' }
+        format.json { render :show, status: :ok, location: @page }
+      else
+        format.html { render :edit }
+        format.json { render json: @page.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def destroy
+    authorize @page
+    @page.destroy
+    respond_to do |format|
+      format.html { redirect_to admin_pages_url, notice: 'Page was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+
+    def page_params
+      page_attributes = [
+        :title, :slug, :description, :status, :featured_image_id, :redirect,
+        :media_item_ids, :parent_page_id, :ancestor_page_id, :scheduled_date, :path,
+        **BlockSlot.blockable_params
+      ]
+      # TODO: come up with a better pattern for adding additional params via the host app, rather than
+      # just permitting all other column_names of the class.
+      column_names = (@page.class.column_names.collect(&:to_sym) - page_attributes).reject { |a| [:id, :created_at, :updated_at].include?(a) }
+      # Attributes from store_accessors
+      stored_attributes = @page.class.stored_attributes.values.flatten
+      permitted_attributes = page_attributes + column_names + stored_attributes
+      params.require(:page).permit(permitted_attributes)
+    end
+
+    def set_page
+      @page = Page.includes(block_slots: [:block_kind, :block]).find(params[:id])
+    end
+
+    def set_block_layout
+      @block_layout = BlockLayout.find_by_slug('default')
+    end
+
+    def set_block_kinds
+      @block_kinds = BlockKind.all
+    end
+end