comfy_middle_seat 3.2.0

data/app/controllers/comfy/admin/cms/sites_controller.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class Comfy::Admin::Cms::SitesController < Comfy::Admin::Cms::BaseController
+  skip_before_action :load_admin_site,
+                     :load_seeds
+
+  before_action :build_site,  only: %i[new create]
+  before_action :load_site,   only: %i[edit update destroy]
+  before_action :authorize
+
+  def index
+    return redirect_to action: :new if ::Comfy::Cms::Site.none?
+
+    @site   = ::Comfy::Cms::Site.find_by_id(session[:site_id])
+    @sites  = ::Comfy::Cms::Site.all
+  end
+
+  def new
+    render
+  end
+
+  def edit
+    render
+  end
+
+  def create
+    @site.save!
+    flash[:success] = I18n.t('comfy.admin.cms.sites.created')
+    redirect_to comfy_admin_cms_site_layouts_path(@site)
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = I18n.t('comfy.admin.cms.sites.creation_failure')
+    render action: :new
+  end
+
+  def update
+    @site.update!(site_params)
+    flash[:success] = I18n.t('comfy.admin.cms.sites.updated')
+    redirect_to action: :edit, id: @site
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = I18n.t('comfy.admin.cms.sites.update_failure')
+    render action: :edit
+  end
+
+  def destroy
+    @site.destroy
+    flash[:success] = I18n.t('comfy.admin.cms.sites.deleted')
+    redirect_to action: :index
+  end
+
+protected
+
+  def build_site
+    @site = ::Comfy::Cms::Site.new(site_params)
+    @site.hostname ||= request.host.downcase
+  end
+
+  def load_site
+    @site = ::Comfy::Cms::Site.find(params[:id])
+    I18n.locale = ComfortableMediaSurfer.config.admin_locale || @site.locale
+  rescue ActiveRecord::RecordNotFound
+    flash[:danger] = I18n.t('comfy.admin.cms.sites.not_found')
+    redirect_to action: :index
+  end
+
+  def site_params
+    params.fetch(:site, {}).permit(:label, :identifier, :hostname, :path, :locale)
+  end
+end

data/app/controllers/comfy/admin/cms/snippets_controller.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class Comfy::Admin::Cms::SnippetsController < Comfy::Admin::Cms::BaseController
+  include ::Comfy::ReorderAction
+
+  self.reorder_action_resource = ::Comfy::Cms::Snippet
+
+  before_action :build_snippet, only: %i[new create]
+  before_action :load_snippet,  only: %i[edit update destroy]
+  before_action :authorize
+
+  def index
+    return redirect_to action: :new if @site.snippets.none?
+
+    @snippets = @site.snippets.includes(:categories).for_category(params[:categories]).order(:position)
+  end
+
+  def new
+    render
+  end
+
+  def edit
+    @snippet.attributes = snippet_params
+  end
+
+  def create
+    @snippet.save!
+    flash[:success] = I18n.t('comfy.admin.cms.snippets.created')
+    redirect_to action: :edit, id: @snippet
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = I18n.t('comfy.admin.cms.snippets.creation_failure')
+    render action: :new
+  end
+
+  def update
+    @snippet.update!(snippet_params)
+    flash[:success] = I18n.t('comfy.admin.cms.snippets.updated')
+    redirect_to action: :edit, id: @snippet
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = I18n.t('comfy.admin.cms.snippets.update_failure')
+    render action: :edit
+  end
+
+  def destroy
+    @snippet.destroy
+    flash[:success] = I18n.t('comfy.admin.cms.snippets.deleted')
+    redirect_to action: :index
+  end
+
+protected
+
+  def build_snippet
+    @snippet = @site.snippets.new(snippet_params)
+  end
+
+  def load_snippet
+    @snippet = @site.snippets.find(params[:id])
+  rescue ActiveRecord::RecordNotFound
+    flash[:danger] = I18n.t('comfy.admin.cms.snippets.not_found')
+    redirect_to action: :index
+  end
+
+  def snippet_params
+    params.fetch(:snippet, {}).permit(:label, :identifier, :markdown, :content, category_ids: [])
+  end
+end

data/app/controllers/comfy/admin/cms/translations_controller.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+class Comfy::Admin::Cms::TranslationsController < Comfy::Admin::Cms::BaseController
+  FRAGMENT_PARAMS = [
+    :identifier, :tag, :content, :datetime, :boolean, :files,
+    { files: [], file_ids_destroy: [] }
+  ].freeze
+
+  helper_method :translation_select_options
+
+  before_action :load_page
+  before_action :build_translation,   only: %i[new create]
+  before_action :load_translation,    only: %i[edit update destroy]
+  before_action :authorize
+  before_action :assign_translation_params, only: :update
+  before_action :preview_translation, only: %i[create update]
+
+  def new
+    render
+  end
+
+  def edit
+    render
+  end
+
+  def create
+    @translation.save!
+    flash[:success] = I18n.t('comfy.admin.cms.translations.created')
+    redirect_to action: :edit, id: @translation
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = I18n.t('comfy.admin.cms.translations.creation_failure')
+    render action: :new
+  end
+
+  def update
+    @translation.save!
+    flash[:success] = I18n.t('comfy.admin.cms.translations.updated')
+    redirect_to action: :edit, id: @translation
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = I18n.t('comfy.admin.cms.translations.update_failure')
+    render action: :edit
+  end
+
+  def destroy
+    @translation.destroy
+    flash[:success] = I18n.t('comfy.admin.cms.translations.deleted')
+    redirect_to edit_comfy_admin_cms_site_page_path(@site, @page)
+  end
+
+  def form_fragments
+    @translation = @page.translations.find_by(id: params[:id]) || @page.translations.new
+    @translation.layout = @site.layouts.find_by(id: params[:layout_id])
+
+    render(
+      partial: 'comfy/admin/cms/fragments/form_fragments',
+      locals: { record: @translation, scope: :translation },
+      layout: false
+    )
+  end
+
+private
+
+  def translation_select_options
+    all = ComfortableMediaSurfer.config.locales
+    taken = @page.translations.pluck(:locale) + [@site.locale] - [@translation.locale]
+    all.except(*taken).map { |k, v| ["#{v} (#{k})", k] }
+  end
+
+  def load_page
+    @page = @site.pages.find(params[:page_id])
+  rescue ActiveRecord::RecordNotFound
+    flash[:danger] = I18n.t('comfy.admin.cms.pages.not_found')
+    redirect_to comfy_admin_cms_site_pages_path(@site)
+  end
+
+  def build_translation
+    @translation = @page.translations.new(translation_params)
+    @translation.layout ||= @page.layout
+  end
+
+  def load_translation
+    @translation = @page.translations.find(params[:id])
+  rescue ActiveRecord::RecordNotFound
+    flash[:danger] = I18n.t('comfy.admin.cms.translations.not_found')
+    redirect_to edit_comfy_admin_cms_site_page_path(@site, @page)
+  end
+
+  def assign_translation_params
+    @translation.assign_attributes(translation_params)
+  end
+
+  def translation_params
+    params.fetch(:translation, {}).permit(
+      :locale, :label, :layout_id, :is_published,
+      fragments_attributes: FRAGMENT_PARAMS
+    )
+  end
+
+  def preview_translation
+    return unless params[:preview]
+
+    layout = @translation.layout.app_layout.blank? ? false : @translation.layout.app_layout
+    @cms_site   = @page.site
+    @cms_layout = @translation.layout
+    @cms_page   = @page
+
+    # Make sure to use the site locale to render the preview becaue it might
+    # be different from the admin locale.
+    I18n.locale = @translation.locale
+
+    # Chrome chokes on content with iframes. Issue #434
+    response.headers['X-XSS-Protection'] = '0'
+
+    # raise
+    render inline: @translation.render, layout: layout, content_type: 'text/html'
+  end
+end

data/app/controllers/comfy/cms/assets_controller.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Comfy::Cms::AssetsController < Comfy::Cms::BaseController
+  skip_before_action :verify_authenticity_token, raise: false
+
+  before_action :load_cms_layout,
+                :use_null_session
+
+  after_action :set_cache_control_header
+
+  def render_css
+    render body: @cms_layout.css, content_type: 'text/css'
+  end
+
+  def render_js
+    render body: @cms_layout.js, content_type: 'application/javascript'
+  end
+
+protected
+
+  def load_cms_layout
+    @cms_layout = @cms_site.layouts.find_by_identifier!(params[:identifier])
+  rescue ActiveRecord::RecordNotFound
+    render body: nil, status: 404
+  end
+
+  # null_session avoids cookies and flash updates
+  def use_null_session
+    ActionController::RequestForgeryProtection::ProtectionMethods::NullSession.new(self)
+      .handle_unverified_request
+  end
+
+  def set_cache_control_header
+    return unless params[:cache_buster].present?
+
+    response.headers['Cache-Control'] = "public, max-age=#{1.year.to_i}"
+  end
+end

data/app/controllers/comfy/cms/base_controller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Comfy::Cms::BaseController < ComfortableMediaSurfer.config.public_base_controller.to_s.constantize
+  before_action :load_cms_site
+
+  helper Comfy::CmsHelper
+
+protected
+
+  def load_cms_site
+    route_site_id = request.path_parameters[:site_id]
+    @cms_site ||= if route_site_id
+                    find_cms_site_for_asset(route_site_id)
+                  else
+                    ::Comfy::Cms::Site.find_site(request.host_with_port.downcase, request.fullpath)
+                  end
+
+    raise ActionController::RoutingError, 'Site Not Found' unless @cms_site
+
+    return unless @cms_site.path.present? && !route_site_id
+    raise ActionController::RoutingError, 'Site Not Found' unless params[:cms_path]&.match(%r{\A#{@cms_site.path}})
+
+    params[:cms_path].gsub!(%r{\A#{@cms_site.path}}, '')
+    params[:cms_path]&.gsub!(%r{\A/}, '')
+  end
+
+  def find_cms_site_for_asset(site_id)
+    site = ::Comfy::Cms::Site.find_by_id(site_id)
+    return site if site && ::Comfy::Cms::Site.one?
+    return unless site
+
+    request_host = ::Comfy::Cms::Site.real_host_from_aliases(request.host_with_port.downcase)
+    site if site.hostname.downcase == request_host
+  end
+end

data/app/controllers/comfy/cms/content_controller.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+class Comfy::Cms::ContentController < Comfy::Cms::BaseController
+  # Authentication module must have `authenticate` method
+  include ComfortableMediaSurfer.config.public_auth.to_s.constantize
+
+  # Authorization module must have `authorize` method
+  include ComfortableMediaSurfer.config.public_authorization.to_s.constantize
+
+  before_action :load_seeds
+  before_action :load_cms_page,
+                :authenticate,
+                :authorize,
+                only: :show
+
+  def show
+    if @cms_page.target_page.present?
+      redirect_to @cms_page.target_page.url(relative: true)
+    else
+      respond_to do |format|
+        format.html { render_page }
+        format.json do
+          @cms_page.content = render_to_string(
+            inline: @cms_page.content_cache,
+            layout: false
+          )
+          json_page = @cms_page.as_json(ComfortableMediaSurfer.config.page_to_json_options)
+          render json: json_page
+        end
+      end
+    end
+  end
+
+protected
+
+  def render_page(status = :ok)
+    render inline: @cms_page.content_cache,
+           layout: app_layout,
+           status: status,
+           content_type: mime_type
+  end
+
+  # it's possible to control mimetype of a page by creating a `mime_type` field
+  def mime_type
+    mime_block = @cms_page.fragments.detect { |f| f.identifier == 'mime_type' }
+    mime_block&.content&.strip || 'text/html'
+  end
+
+  def app_layout
+    return false if request.xhr? || !@cms_layout
+
+    @cms_layout.app_layout.present? ? @cms_layout.app_layout : false
+  end
+
+  def load_seeds
+    return unless ComfortableMediaSurfer.config.enable_seeds
+
+    ComfortableMediaSurfer::Seeds::Importer.new(@cms_site.identifier).import!
+  end
+
+  # Attempting to populate @cms_page and @cms_layout instance variables so they
+  # can be used in view helpers/partials
+  def load_cms_page
+    return if find_cms_page_by_full_path("/#{params[:cms_path]}")
+
+    if find_cms_page_by_full_path('/404')
+      render_page(:not_found)
+    else
+      message = "Page Not Found at: \"#{params[:cms_path]}\""
+      raise ActionController::RoutingError, message
+    end
+  end
+
+  # Getting page and setting content_cache and fragments data if we need to
+  # serve translation data
+  def find_cms_page_by_full_path(full_path)
+    @cms_page = if Rails.env == 'development'
+                  @cms_site.pages.find_by!(full_path: full_path)
+                else
+                  @cms_site.pages.published.find_by!(full_path: full_path)
+                end
+
+    @cms_page.translate!
+    @cms_layout = @cms_page.layout
+
+    @cms_page
+  rescue ActiveRecord::RecordNotFound
+    nil
+  end
+end

data/app/controllers/concerns/comfy/paginate.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Comfy::Paginate
+  def comfy_paginate(scope, per_page: 50)
+    if defined?(Kaminari)
+      scope.page(params[:page]).per(per_page)
+    else
+      scope
+    end
+  end
+end

data/app/controllers/concerns/comfy/reorder_action.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Comfy::ReorderAction
+  extend ActiveSupport::Concern
+
+  included do
+    mattr_accessor :reorder_action_resource
+  end
+
+  def reorder
+    resource_class = self.class.reorder_action_resource
+    site_resources = resource_class.where(site_id: @site.id)
+    (params.permit(order: [])[:order] || []).each_with_index do |id, index|
+      site_resources.where(id: id).update_all(position: index)
+    end
+    @site.pages.each(&:save!) if resource_class == ::Comfy::Cms::Page
+    head :ok
+  end
+end

data/app/helpers/comfy/admin/cms_helper.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Comfy
+  module Admin
+    module CmsHelper
+      # Wrapper around Comfy::FormBuilder
+      def comfy_form_with(**options, &)
+        form_options = options.merge(builder: ComfortableMediaSurfer::FormBuilder)
+        form_options[:bootstrap]  = { layout: :horizontal }
+        form_options[:local]      = true
+        bootstrap_form_with(**form_options, &)
+      end
+
+      def comfy_admin_partial(path, params = {})
+        render path, params
+      rescue ActionView::MissingTemplate
+        if ComfortableMediaSurfer.config.reveal_cms_partials
+          content_tag(:div, class: 'comfy-admin-partial') do
+            path
+          end
+        end
+      end
+
+      # Injects some content somewhere inside cms admin area
+      def cms_hook(name, options = {})
+        ComfortableMediaSurfer::ViewHooks.render(name, self, options)
+      end
+
+      # @param [String] fragment_id
+      # @param [ActiveStorage::Blob] attachment
+      # @param [Boolean] multiple
+      # @return [String] {{ cms:page_file_link #{fragment_id}, ... }}
+      def cms_page_file_link_tag(fragment_id:, attachment:, multiple:)
+        filename  = ", filename: \"#{attachment.filename}\""  if multiple
+        as        = ', as: image'                             if attachment.image?
+        "{{ cms:page_file_link #{fragment_id}#{filename}#{as} }}"
+      end
+
+      # @param [Comfy::Cms::File] file
+      # @return [String] {{ cms:file_link #{file.id}, ... }}
+      def cms_file_link_tag(file)
+        if file.attachment.image?
+          "{{ cms:image #{file.label} }}"
+        else
+          "{{ cms:file_link #{file.id} }}"
+        end
+      end
+    end
+  end
+end

data/app/helpers/comfy/cms_helper.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Comfy
+  module CmsHelper
+    # Raw content of a page fragment. This is how you get content from unrenderable
+    # tags like {{cms:fragment meta, render: false}}
+    # Example:
+    #   cms_fragment_content(:left_column, CmsPage.first)
+    #   cms_fragment_content(:left_column) # if @cms_page is present
+    def cms_fragment_content(identifier, page = @cms_page)
+      frag = page&.fragments&.detect { |f| f.identifier == identifier.to_s }
+      return '' unless frag
+
+      case frag.tag
+      when 'date', 'datetime'
+        frag.datetime
+      when 'checkbox'
+        frag.boolean
+      when 'file', 'files'
+        frag.attachments
+      else
+        frag.content
+      end
+    end
+
+    # Same as cms_fragment_content but with cms tags expanded and rendered. Use
+    # it only if you know you got more stuff in the fragment content other than
+    # text because this is a potentially expensive call.
+    def cms_fragment_render(identifier, page = @cms_page)
+      node = page.fragment_nodes.detect { |n| n.identifier == identifier.to_s }
+      return '' unless node
+
+      node.renderable = true
+      render inline: page.render([node])
+    end
+
+    # Raw content of a snippet.
+    # Example:
+    #   cms_snippet_content(:my_snippet)
+    def cms_snippet_content(identifier, cms_site = @cms_site)
+      cms_site ||= cms_site_detect
+      snippet = cms_site&.snippets&.find_by_identifier(identifier)
+      return '' unless snippet
+
+      snippet.content
+    end
+
+    # Same as cms_snippet_content but cms tags will be expanded. Note that there
+    # is no page context, so snippet cannot contain fragment tags.
+    def cms_snippet_render(identifier, cms_site = @cms_site)
+      cms_site ||= cms_site_detect
+      snippet = cms_site&.snippets&.find_by_identifier(identifier)
+      return '' unless snippet
+
+      r = ComfortableMediaSurfer::Content::Renderer.new(snippet)
+      render inline: r.render(r.nodes(r.tokenize(snippet.content)))
+    end
+
+    def cms_site_detect
+      host = request.host_with_port.downcase
+      path = request.fullpath
+      Comfy::Cms::Site.find_site(host, path)
+    end
+
+    def comfy_paginate(collection)
+      return unless collection
+
+      paginate collection, theme: 'comfy' if defined?(Kaminari)
+    end
+  end
+end

data/app/models/comfy/cms/categorization.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Comfy::Cms::Categorization < ActiveRecord::Base
+  self.table_name = 'comfy_cms_categorizations'
+
+  # -- Relationships -----------------------------------------------------------
+  belongs_to :category
+  belongs_to :categorized,
+             polymorphic: true
+
+  # -- Validations -------------------------------------------------------------
+  validates :category_id,
+            uniqueness: { scope: %i[categorized_type categorized_id] }
+  validate :category_belongs_to_site
+
+private
+
+  def category_belongs_to_site
+    return unless category && categorized.respond_to?(:site_id)
+
+    errors.add(:category_id, :invalid) if category.site_id != categorized.site_id
+  end
+end

data/app/models/comfy/cms/category.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Comfy::Cms::Category < ActiveRecord::Base
+  self.table_name = 'comfy_cms_categories'
+
+  # -- Relationships --------------------------------------------------------
+  belongs_to :site
+  has_many :categorizations,
+           dependent: :destroy
+
+  # -- Validations ----------------------------------------------------------
+  validates :label,
+            presence: true,
+            uniqueness: { scope: %i[categorized_type site_id] }
+  validates :categorized_type,
+            presence: true
+
+  # -- Scopes ---------------------------------------------------------------
+  scope :of_type, ->(type) {
+    where(categorized_type: type)
+  }
+end

data/app/models/comfy/cms/file.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class Comfy::Cms::File < ActiveRecord::Base
+  self.table_name = 'comfy_cms_files'
+
+  include Comfy::Cms::WithCategories
+
+  VARIANT_SIZE = {
+    redactor: { resize: '100x75^', gravity: 'center', crop: '100x75+0+0' },
+    thumb: { resize: '200x150^', gravity: 'center', crop: '200x150+0+0' },
+    icon: { resize: '28x28^', gravity: 'center', crop: '28x28+0+0' }
+  }.freeze
+
+  # temporary place to store attachment
+  attr_accessor :file
+
+  has_one_attached :attachment
+
+  # -- Relationships -----------------------------------------------------------
+  belongs_to :site
+
+  # -- Callbacks ---------------------------------------------------------------
+  before_validation :assign_label, on: :create
+  before_create :assign_position
+  # active_storage attachment behavior changed in rails 6
+  before_save :process_attachment
+  after_save :clear_page_content_cache
+
+  # -- Validations -------------------------------------------------------------
+  validates :label, presence: true
+  validates :file, presence: true, on: :create
+
+  # -- Scopes ------------------------------------------------------------------
+  # When we need to grab only files with image attachments.
+  # Don't forget to include `with_attached_attachment` before calling this
+  scope :with_images, -> {
+    where("active_storage_blobs.content_type LIKE 'image/%'").references(:blob)
+  }
+
+private
+
+  def clear_page_content_cache
+    Comfy::Cms::Page.where(id: site.pages.pluck(:id)).update_all(content_cache: nil)
+  end
+
+protected
+
+  def assign_position
+    max = Comfy::Cms::File.maximum(:position)
+    self.position = max ? max + 1 : 0
+  end
+
+  # TODO: Change db schema not to set blank string
+  def assign_label
+    return if label.present?
+
+    self.label = file&.original_filename
+  end
+
+  def process_attachment
+    return if @file.blank?
+
+    self.attachment = @file
+  end
+end