comfy_middle_seat 3.2.0

data/lib/comfortable_media_surfer/form_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class ComfortableMediaSurfer::FormBuilder < ComfyBootstrapForm::FormBuilder
+  # Renders form input for a fragment
+  #
+  # @param [Comfy::Cms::Page] record
+  # @param [ComfortableMediaSurfer::Content::Tag] tag
+  # @param [Integer] index
+  def fragment_field(tag, index)
+    tag.form_field(object_name, @template, index) do |tag_input|
+      name = "#{object_name}[fragments_attributes][#{index}][identifier]"
+      identifer_input = @template.hidden_field_tag(name, tag.identifier, id: nil)
+
+      name  = "#{object_name}[fragments_attributes][#{index}][tag]"
+      value = tag.class.to_s.demodulize.underscore
+      tag_name_input = @template.hidden_field_tag(name, value, id: nil)
+
+      label = I18n.t("comfy.cms.content.tag.#{tag.identifier}", default: tag.identifier.titleize)
+      renderable = tag.respond_to?(:renderable) ? tag.renderable : true
+
+      form_group bootstrap: { label: { text: label, for: tag.form_field_id, class: "renderable-#{renderable}" } } do
+        concat identifer_input
+        concat tag_name_input
+        concat tag_input
+      end
+    end
+  end
+
+  # Wrapper for form action that is sticking to the bottom of the viewport.
+  # Example:
+  #   = form.form_actions do
+  #     = form.submit
+  #
+  def form_actions(&)
+    content_tag(:div, class: 'form-actions row bg-light') do
+      content_tag(:div, class: 'col-lg-8 offset-lg-2') do
+        content_tag(:div, class: 'form-group row mb-0') do
+          content_tag(:div, class: 'col-sm-10 offset-sm-2', &)
+        end
+      end
+    end
+  end
+end

data/lib/comfortable_media_surfer/render_methods.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::RenderMethods
+  def self.included(base)
+    # If application controller doesn't have template associated with it
+    # CMS will attempt to find one. This is so you don't have to explicitly
+    # call render cms_page: '/something'
+    base.rescue_from 'ActionView::MissingTemplate' do |e|
+      render cms_page: request.path
+    rescue ComfortableMediaSurfer::MissingPage, ComfortableMediaSurfer::MissingSite
+      raise e
+    end
+  end
+
+  # Now you can render cms_page simply by calling:
+  #   render cms_page: '/path/to/page'
+  # This way application controllers can use CMS content while populating
+  # instance variables that can be used in partials (that are included by
+  # by the cms page and/or layout)
+  #
+  # Or how about not worrying about setting up CMS pages and rendering
+  # application view using a CMS layout?
+  #   render cms_layout: 'layout_slug', cms_fragments: {
+  #     fragment_identifier_a: 'content text',
+  #     fragment_identifier_b: {template: 'path/to/template' },
+  #     fragment_identifier_c: {partial:  'path/to/partial' }
+  #   }
+  #
+  # This way you are populating page block content and rendering
+  # an instantialized CMS page.
+  #
+  # Site is loaded automatically based on the request. However you can force
+  # it by passing :cms_site parameter with site's slug. For example:
+  #   render cms_page: '/path/to/page', cms_site: 'default'
+  #
+  def render(options = {}, locals = {}, &)
+    return super unless options.is_a?(Hash)
+
+    if (site_identifier = options.delete(:cms_site)) && !(@cms_site = Comfy::Cms::Site.find_by_identifier(site_identifier))
+      raise ComfortableMediaSurfer::MissingSite, site_identifier
+    end
+
+    if ((page_path = options.delete(:cms_page)) || (layout_identifier = options.delete(:cms_layout))) && !@cms_site ||= Comfy::Cms::Site.find_site(
+      request.host_with_port.downcase, request.fullpath
+    )
+      raise ComfortableMediaSurfer::MissingSite, "#{request.host.downcase}/#{request.fullpath}"
+    end
+
+    if page_path
+      render_cms_page(page_path, options, locals, &)
+    elsif layout_identifier
+      render_cms_layout(layout_identifier, options, locals, &)
+    else
+      super
+    end
+  end
+
+  def render_cms_page(path, options = {}, locals = {}, &)
+    path.gsub!(%r{^/#{@cms_site.path}}, '') if @cms_site.path.present?
+
+    unless (@cms_page = @cms_site.pages.find_by_full_path(path))
+      raise ComfortableMediaSurfer::MissingPage, path
+    end
+
+    @cms_page.translate!
+
+    @cms_layout = @cms_page.layout
+    if (cms_fragments = options.delete(:cms_fragments)).present?
+      cms_fragments.each do |identifier, value|
+        content = value.is_a?(Hash) ? render_to_string(value.merge(layout: false)) : value.to_s
+        page_fragment = @cms_page.fragments.detect { |f| f.identifier == identifier.to_s } ||
+                        @cms_page.fragments.build(identifier: identifier.to_s)
+        page_fragment.content = content
+      end
+    end
+    cms_app_layout = @cms_layout.app_layout
+    options[:layout] ||= cms_app_layout.blank? ? nil : cms_app_layout
+    options[:inline] = @cms_page.render
+
+    render(options, locals, &)
+  end
+
+  def render_cms_layout(identifier, options = {}, locals = {}, &)
+    unless (@cms_layout = @cms_site.layouts.find_by_identifier(identifier))
+      raise ComfortableMediaSurfer::MissingLayout, identifier
+    end
+
+    cms_app_layout = @cms_layout.app_layout
+    cms_page = @cms_site.pages.build(layout: @cms_layout)
+    cms_fragments =
+      options.delete(:cms_fragments) || { content: render_to_string({ layout: false }.merge(options)) }
+
+    cms_fragments.each do |frag_identifier, value|
+      content = value.is_a?(Hash) ? render_to_string(value.merge(layout: false)) : value.to_s
+      cms_page.fragments.build(identifier: frag_identifier.to_s, content: content)
+    end
+    options[:layout] ||= cms_app_layout.blank? ? nil : cms_app_layout
+    options[:inline] = cms_page.render
+
+    render(options, locals, &)
+  end
+end
+
+ActiveSupport.on_load :action_controller_base do
+  include ComfortableMediaSurfer::RenderMethods
+end

data/lib/comfortable_media_surfer/routing.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Routing
+  class ActionDispatch::Routing::Mapper
+    def comfy_route_cms_admin(path: 'admin')
+      scope module: :comfy, as: :comfy do
+        scope module: :admin do
+          namespace :cms, as: :admin_cms, path: path, except: :show do
+            get '/', to: 'base#jump'
+
+            # concern :with_revisions do |options|
+            #   resources :revisions, options.merge(only: %i[index show]) do
+            #     patch :revert, on: :member
+            #   end
+            # end
+
+            concern :with_revisions do |options|
+              resources :revisions, **options, only: %i[index show] do
+                patch :revert, on: :member
+              end
+            end
+
+            concern :with_reorder do
+              put :reorder, on: :collection
+            end
+
+            concern :with_form_fragments do
+              get :form_fragments, on: :member
+            end
+
+            resources :sites do
+              resources :pages do
+                concerns :with_reorder
+                concerns :with_form_fragments
+                concerns :with_revisions, controller: 'revisions/page'
+
+                get :toggle_branch, on: :member
+                patch :publish_children, on: :member
+                patch :unpublish_children, on: :member
+
+                resources :translations, except: [:index] do
+                  concerns :with_form_fragments
+                  concerns :with_revisions, controller: 'revisions/translation'
+                end
+              end
+
+              resources :files, concerns: [:with_reorder]
+
+              resources :layouts do
+                concerns :with_reorder
+                concerns :with_revisions, controller: 'revisions/layout'
+              end
+
+              resources :snippets do
+                concerns :with_reorder
+                concerns :with_revisions, controller: 'revisions/snippet'
+              end
+
+              resources :categories
+            end
+          end
+        end
+      end
+    end
+  end
+
+  class ActionDispatch::Routing::Mapper
+    def comfy_route_cms(options = {})
+      ComfortableMediaSurfer.configuration.public_cms_path = options[:path]
+
+      scope module: :comfy, as: :comfy do
+        namespace :cms, path: options[:path] do
+          get 'cms-css/:site_id/:identifier(/:cache_buster)' => 'assets#render_css', as: 'render_css'
+          get 'cms-js/:site_id/:identifier(/:cache_buster)'  => 'assets#render_js',  as: 'render_js'
+
+          get '(*cms_path)' => 'content#show', as: 'render_page', action: '/:format'
+        end
+      end
+    end
+  end
+
+  class ActionDispatch::Routing::Mapper
+    def comfy_route(identifier, options = {})
+      send("comfy_route_#{identifier}", **options)
+    end
+  end
+end

data/lib/comfortable_media_surfer/seeds/file/exporter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::File
+  class Exporter < ComfortableMediaSurfer::Seeds::Exporter
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, to, 'files/')
+    end
+
+    def export!
+      prepare_folder!(path)
+
+      site.files.each do |file|
+        file_path = File.join(path, file.attachment.filename.to_s)
+
+        # writing attributes
+        ::File.write(::File.join(path, "_#{file.attachment.filename}.yml"), {
+          'label' => file.label,
+          'description' => file.description,
+          'categories' => file.categories.map(&:label)
+        }.to_yaml)
+
+        # writing content
+        begin
+          ::File.binwrite(::File.join(path, ::File.basename(file_path)), file.attachment.download)
+        rescue Errno::ENOENT, OpenURI::HTTPError
+          message = "[CMS SEEDS] No physical File \t #{file.attachment.filename}"
+          ComfortableMediaSurfer.logger.warn(message)
+          next
+        end
+
+        message = "[CMS SEEDS] Exported File \t #{file.attachment.filename}"
+        ComfortableMediaSurfer.logger.info(message)
+      end
+    end
+  end
+end

data/lib/comfortable_media_surfer/seeds/file/importer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::File
+  class Importer < ComfortableMediaSurfer::Seeds::Importer
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, from, 'files/')
+    end
+
+    def import!
+      Dir["#{path}[^_]*"].each do |file_path|
+        filename = ::File.basename(file_path)
+
+        file = site.files.with_attached_attachment
+          .where('active_storage_blobs.filename' => filename).references(:blob).first ||
+               site.files.new
+
+        if File.exist?(attrs_path = File.join(path, "_#{filename}.yml")) && fresh_seed?(file, attrs_path)
+          attrs = YAML.safe_load_file(attrs_path)
+          category_ids = category_names_to_ids(file, attrs.delete('categories'))
+          file.attributes = attrs.merge(
+            category_ids: category_ids
+          )
+          save(file, file_path)
+        end
+
+        if fresh_seed?(file, file_path)
+          File.open(file_path) do |file_handler|
+            file.file = {
+              io: file_handler,
+              filename: filename,
+              content_type: MimeMagic.by_magic(file_handler)
+            }
+            save(file, file_path)
+          end
+        end
+
+        seed_ids << file.id
+      end
+
+      # cleaning up
+      site.files.where('id NOT IN (?)', seed_ids).destroy_all
+    end
+
+  private
+
+    def save(file, path)
+      if file.save
+        ComfortableMediaSurfer.logger.info("[CMS SEEDS] Imported File \t #{path}")
+      else
+        ComfortableMediaSurfer.logger.warn("[CMS SEEDS] Failed to import File \n#{file.errors.inspect}")
+      end
+    end
+  end
+end

data/lib/comfortable_media_surfer/seeds/layout/exporter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::Layout
+  class Exporter < ComfortableMediaSurfer::Seeds::Exporter
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, to, 'layouts/')
+    end
+
+    def export!
+      prepare_folder!(path)
+
+      site.layouts.each do |layout|
+        layout_path = File.join(path, layout.ancestors.reverse.collect(&:identifier), layout.identifier)
+        FileUtils.mkdir_p(layout_path)
+
+        path = ::File.join(layout_path, 'content.html')
+        data = []
+
+        attrs = {
+          'label' => layout.label,
+          'app_layout' => layout.app_layout,
+          'position' => layout.position
+        }.to_yaml
+
+        data << { header: 'attributes',  content: attrs }
+        data << { header: 'content',     content: layout.content }
+        data << { header: 'js',          content: layout.js }
+        data << { header: 'css',         content: layout.css }
+
+        write_file_content(path, data)
+
+        message = "[CMS SEEDS] Exported Layout \t #{layout.identifier}"
+        ComfortableMediaSurfer.logger.info(message)
+      end
+    end
+  end
+end

data/lib/comfortable_media_surfer/seeds/layout/importer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::Layout
+  class Importer < ComfortableMediaSurfer::Seeds::Importer
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, from, 'layouts/')
+    end
+
+    def import!(path = self.path, parent = nil)
+      Dir["#{path}*/"].each do |layout_path|
+        import_layout(layout_path, parent)
+      end
+
+      # cleaning up
+      site.layouts.where('id NOT IN (?)', seed_ids).destroy_all
+    end
+
+  private
+
+    def import_layout(path, parent)
+      identifier = path.split('/').last
+
+      # reading file content in, resulting in a hash
+      content_path = File.join(path, 'content.html')
+      content_hash = parse_file_content(content_path)
+
+      # parsing attributes section
+      attributes_yaml = content_hash.delete('attributes')
+      attrs           = YAML.safe_load(attributes_yaml)
+
+      layout = site.layouts.where(identifier: identifier).first_or_initialize
+      layout.parent = parent
+
+      if fresh_seed?(layout, content_path)
+        layout.attributes = attrs.merge(
+          app_layout: attrs['app_layout'] || parent.try(:app_layout),
+          content: content_hash['content'],
+          js: content_hash['js'],
+          css: content_hash['css']
+        )
+
+        if layout.save
+          message = "[CMS SEEDS] Imported Layout \t #{layout.identifier}"
+          ComfortableMediaSurfer.logger.info(message)
+        else
+          message = "[CMS SEEDS] Failed to import Layout \n#{layout.errors.inspect}"
+          ComfortableMediaSurfer.logger.warn(message)
+        end
+      end
+
+      seed_ids << layout.id
+
+      # importing child layouts (if there are any)
+      Dir["#{path}*/"].each do |layout_path|
+        import_layout(layout_path, layout)
+      end
+    end
+  end
+end

data/lib/comfortable_media_surfer/seeds/page/exporter.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Seeds::Page
+  class Exporter < ComfortableMediaSurfer::Seeds::Exporter
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMediaSurfer.config.seeds_path, to, 'pages/')
+    end
+
+    def export!
+      prepare_folder!(path)
+
+      site.pages.each do |page|
+        page.slug = 'index' if page.slug.blank?
+        page_path = File.join(path, page.ancestors.reverse.map { |p| p.slug.blank? ? 'index' : p.slug }, page.slug)
+        FileUtils.mkdir_p(page_path)
+
+        path = ::File.join(page_path, 'content.html')
+        data = []
+
+        attrs = {
+          'label' => page.label,
+          'layout' => page.layout.try(:identifier),
+          'target_page' => page.target_page.try(:full_path),
+          'categories' => page.categories.map(&:label),
+          'is_published' => page.is_published,
+          'position' => page.position
+        }.to_yaml
+
+        data << { header: 'attributes', content: attrs }
+        data += fragments_data(page, page_path)
+
+        write_file_content(path, data)
+
+        message = "[CMS SEEDS] Exported Page \t #{page.full_path}"
+        ComfortableMediaSurfer.logger.info(message)
+
+        export_translations(page, page_path)
+      end
+    end
+
+  private
+
+    def export_translations(page, page_path)
+      page.translations.each do |translation|
+        path = ::File.join(page_path, "content.#{translation.locale}.html")
+        data = []
+
+        attrs = {
+          'label' => translation.label,
+          'layout' => translation.layout.try(:identifier),
+          'is_published' => page.is_published
+        }.to_yaml
+
+        data << { header: 'attributes', content: attrs }
+        data += fragments_data(translation, page_path)
+
+        write_file_content(path, data)
+
+        message = "[CMS SEEDS] Exported Translation \t #{translation.locale}"
+        ComfortableMediaSurfer.logger.info(message)
+      end
+    end
+
+    # Collecting fragment data and writing attachment files to disk
+    def fragments_data(record, page_path)
+      record.fragments.collect do |frag|
+        header = "#{frag.tag} #{frag.identifier}"
+        content =
+          case frag.tag
+          when 'datetime', 'date'
+            frag.datetime
+          when 'checkbox'
+            frag.boolean
+          when 'file', 'files'
+            frag.attachments.map do |attachment|
+              ::File.binwrite(::File.join(page_path, attachment.filename.to_s), attachment.download)
+              attachment.filename
+            end.join("\n")
+          else
+            frag.content
+          end
+
+        { header: header, content: content }
+      end
+    end
+  end
+end