maglevcms 1.0.0.rc1

data/app/components/maglev/tag_helper.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Maglev
+  module TagHelper
+    def wrapper_tag(options = nil, &block)
+      return WrapperTagBuilder.new(view_context, self) if options.nil?
+
+      tag_options = (options || {}).merge(id: dom_id)
+      tag_options[:data] = (tag_options[:data] || {}).merge(tag_data)
+      content = view_context.capture(&block)
+      view_context.tag.public_send(
+        tag_options.delete(:html_tag) || :div,
+        content,
+        **tag_options
+      )
+    end
+
+    def setting_tag(setting_id, options = {}, &block)
+      # setting = settings.public_send(setting_id)
+      find_setting(settings, setting_id).tag(view_context, options, &block)
+    end
+
+    class WrapperTagBuilder
+      attr_reader :view_context, :component
+
+      def initialize(view_context, component)
+        @view_context = view_context
+        @component = component
+      end
+
+      def method_missing(name, options = nil, &block)
+        component.wrapper_tag(
+          (options || {}).merge(html_tag: name),
+          &block
+        )
+      end
+
+      def respond_to_missing?
+        true
+      end
+    end
+  end
+end

data/app/controllers/concerns/maglev/authentication_concern.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Maglev
+  module AuthenticationConcern
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :require_authentication
+    end
+
+    private
+
+    def require_authentication
+      raise Maglev::Errors::NotAuthorized unless authenticated_in_app?
+
+      session[:maglev_site_id] = maglev_site.id
+    end
+
+    def authenticated_in_app?
+      case maglev_config.is_authenticated
+      when nil
+        # NOTE: this use case must not happen
+        raise 'The Maglev configuration requires the is_authenticated setting. Please read the documentation.'
+      when Symbol
+        send(maglev_config.is_authenticated, maglev_site)
+      when Proc
+        instance_exec(maglev_site, &maglev_config.is_authenticated)
+      end
+    end
+  end
+end

data/app/controllers/concerns/maglev/back_action_concern.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Maglev
+  module BackActionConcern
+    private
+
+    def call_back_action
+      maglev_redirect_on_leaving
+    end
+
+    def maglev_redirect_on_leaving
+      case maglev_config.back_action
+      when nil
+        redirect_to maglev_default_leave_url
+      when String
+        redirect_to maglev_config.back_action
+      when Symbol
+        redirect_to main_app.send(maglev_config.back_action)
+      when Proc
+        instance_exec(maglev_site, &maglev_config.back_action)
+      end
+    end
+
+    def maglev_default_leave_url
+      main_app.root_path
+    rescue StandardError
+      '/'
+    end
+  end
+end

data/app/controllers/concerns/maglev/content_locale_concern.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Maglev
+  module ContentLocaleConcern
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :content_locale
+    end
+
+    private
+
+    def set_content_locale
+      locale = params[:locale] || request.headers['X-MAGLEV-LOCALE']
+      Maglev::I18n.current_locale = locale if locale
+    end
+
+    def content_locale
+      Maglev::I18n.current_locale
+    end
+
+    def default_content_locale
+      maglev_site.default_locale.prefix
+    end
+  end
+end

data/app/controllers/concerns/maglev/fetchers_concern.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Maglev
+  module FetchersConcern
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :maglev_site, :maglev_theme, :maglev_page, :maglev_page_sections, :maglev_sections_path,
+                    :maglev_site_root_fullpath, :maglev_page_fullpaths, :maglev_style
+    end
+
+    private
+
+    def fetch_maglev_page_content
+      fetch_maglev_site
+      fetch_maglev_theme
+      fetch_maglev_page
+
+      raise ActionController::RoutingError, 'Maglev page not found' unless fetch_maglev_page
+
+      fetch_maglev_page_sections
+    end
+
+    def fetch_maglev_site
+      @fetch_maglev_site ||= maglev_services.fetch_site.call
+    end
+
+    def fetch_maglev_page
+      @fetch_maglev_page ||= maglev_services.fetch_page.call(
+        path: params[:path],
+        locale: content_locale,
+        default_locale: default_content_locale,
+        fallback_to_default_locale: fallback_to_default_locale
+      )
+    end
+
+    def fetch_maglev_page_sections(page_sections = nil)
+      @fetch_maglev_page_sections ||= maglev_services.get_page_sections.call(
+        page: fetch_maglev_page,
+        page_sections: page_sections,
+        locale: content_locale
+      )
+    end
+
+    def fetch_maglev_theme
+      @fetch_maglev_theme ||= maglev_services.fetch_theme.call
+    end
+
+    def fetch_maglev_theme_layout
+      @fetch_maglev_theme_layout ||= maglev_services.fetch_theme_layout.call
+    end
+
+    def fetch_maglev_sections_path
+      @fetch_maglev_sections_path ||= maglev_services.fetch_sections_path.call
+    end
+
+    def fallback_to_default_locale
+      false
+    end
+
+    ## accessors for view helpers ##
+
+    def maglev_site
+      fetch_maglev_site
+    end
+
+    def maglev_theme
+      fetch_maglev_theme
+    end
+
+    def maglev_page
+      fetch_maglev_page
+    end
+
+    def maglev_page_sections
+      fetch_maglev_page_sections
+    end
+
+    def maglev_sections_path
+      fetch_maglev_sections_path
+    end
+
+    def maglev_site_root_fullpath
+      maglev_services.get_page_fullpath.call(
+        path: 'index',
+        locale: content_locale,
+        preview_mode: maglev_rendering_mode != :live
+      )
+    end
+
+    def maglev_page_fullpaths
+      maglev_site.locale_prefixes.inject({}) do |memo, locale|
+        memo.merge(locale => maglev_services.get_page_fullpath.call(
+          page: maglev_page,
+          locale: locale,
+          preview_mode: maglev_rendering_mode != :live
+        ))
+      end
+    end
+
+    def maglev_style
+      maglev_services.fetch_style.call(
+        site: maglev_site,
+        theme: maglev_theme
+      )
+    end
+  end
+end

data/app/controllers/concerns/maglev/json_concern.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Maglev
+  module JSONConcern
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :underscore_params!
+    end
+
+    protected
+
+    def underscore_params!
+      params.instance_variable_get(:@parameters).deep_transform_keys!(&:underscore)
+    end
+  end
+end
+
+Maglev::JsonConcern = Maglev::JSONConcern

data/app/controllers/concerns/maglev/rendering_concern.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Maglev
+  module RenderingConcern
+    extend ActiveSupport::Concern
+
+    included do
+      include Maglev::FetchersConcern
+    end
+
+    private
+
+    def render_maglev_page
+      raise ActionController::UnknownFormat, 'Maglev renders HTML pages only' if request.format != 'html'
+
+      fetch_maglev_page_content
+
+      verify_canonical_path and return
+
+      render template: fetch_maglev_theme_layout, layout: false
+    end
+
+    def verify_canonical_path
+      # the section mode is only used to display the content of a single section
+      # in the admin UI.
+      return if maglev_rendering_mode == :section
+
+      # check if we're processing the right version (canonical) of the page
+      # if not, follow the proper SEO rule by redirecting the user with a 301
+      canonical_path = maglev_page.path
+
+      return false if !canonical_path || params[:path] == canonical_path
+
+      next_path = maglev_rendering_mode == :editor ? site_preview_path(path: canonical_path) : "/#{canonical_path}"
+      redirect_to next_path, status: :moved_permanently
+
+      true
+    end
+  end
+end

data/app/controllers/concerns/maglev/services_concern.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Maglev
+  module ServicesConcern
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :maglev_config, :maglev_services
+    end
+
+    private
+
+    def services
+      # NOTE: neither alias nor alias_method could work in the PRO engine
+      maglev_services
+    end
+
+    def maglev_services
+      @maglev_services ||= ::Maglev.services(
+        context: build_maglev_service_context
+      )
+    end
+
+    def build_maglev_service_context
+      ::Maglev::ServiceContext.new(
+        rendering_mode: maglev_rendering_mode,
+        controller: self
+      )
+    end
+
+    def maglev_rendering_mode
+      :live
+    end
+
+    def maglev_config
+      Maglev.config
+    end
+  end
+end

data/app/controllers/concerns/maglev/standalone_sections_concern.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Maglev
+  module StandaloneSectionsConcern
+    extend ActiveSupport::Concern
+
+    included do
+      include Maglev::ServicesConcern
+      include Maglev::FetchersConcern
+      include Maglev::ContentLocaleConcern
+
+      helper Maglev::PagePreviewHelper
+    end
+
+    private
+
+    def fetch_maglev_site_scoped_sections
+      fetch_maglev_site
+      fetch_maglev_theme
+      fetch_maglev_dummy_page
+      fetch_maglev_page_sections
+    end
+
+    def fetch_maglev_dummy_page
+      @fetch_maglev_page = ::Maglev::Page.new(title: 'DummyPage', sections: fetch_maglev_site.sections)
+    end
+  end
+end

data/app/controllers/concerns/maglev/ui_locale_concern.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Maglev
+  module UiLocaleConcern
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :set_ui_locale
+
+      helper_method :editor_ui_locale
+    end
+
+    private
+
+    def set_ui_locale
+      ::I18n.locale = editor_ui_locale
+    end
+
+    def editor_ui_locale
+      case maglev_config.ui_locale
+      when nil
+        ::I18n.locale
+      when String
+        maglev_config.ui_locale.to_sym
+      when Symbol
+        send(maglev_config.ui_locale)
+      when Proc
+        instance_exec(maglev_site, &maglev_config.ui_locale)
+      end
+    end
+  end
+end

data/app/controllers/maglev/admin/base_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Admin
+    class BaseController < ::Maglev::ApplicationController
+      layout 'maglev/admin/application'
+
+      before_action :maglev_authenticate
+
+      private
+
+      def maglev_authenticate
+        username = maglev_config.admin_username
+        password = maglev_config.admin_password
+        return if !username || !password
+
+        redirect_to main_app.root_path unless authenticate_with_http_basic { |u, p| username == u && password == p }
+      end
+    end
+  end
+end

data/app/controllers/maglev/admin/dashboard_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Admin
+    class DashboardController < BaseController
+      def index
+        redirect_to admin_theme_path
+      end
+    end
+  end
+end

data/app/controllers/maglev/admin/sections/previews_controller.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Admin
+    module Sections
+      class PreviewsController < BaseController
+        include Maglev::RenderingConcern
+        include Maglev::ContentLocaleConcern
+
+        helper ::Maglev::PagePreviewHelper
+
+        def show
+          @section = fetch_section
+        end
+
+        def iframe_show
+          render_maglev_page
+        end
+
+        private
+
+        def fetch_maglev_page
+          Maglev::Page.new(
+            title: 'Preview section',
+            path: 'preview',
+            sections: [fetch_section!.build_default_content]
+          )
+        end
+
+        def fetch_section!
+          fetch_section || (raise ::Maglev::Errors::UnknownSection, "Unknown section #{params[:id]}")
+        end
+
+        def fetch_section
+          @fetch_section ||= fetch_maglev_theme.sections.find(params[:id])
+        end
+
+        def maglev_rendering_mode
+          :section
+        end
+
+        def use_engine_webpacker?
+          action_name == 'show'
+        end
+
+        def content_locale
+          default_content_locale
+        end
+      end
+    end
+  end
+end

data/app/controllers/maglev/admin/sections/screenshots_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Admin
+    module Sections
+      class ScreenshotsController < BaseController
+        def create
+          services.persist_section_screenshot.call(
+            section_id: params[:id],
+            base64_image: params[:screenshot][:base64_image]
+          )
+          head :created
+        end
+      end
+    end
+  end
+end

data/app/controllers/maglev/admin/themes_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Admin
+    class ThemesController < BaseController
+      helper_method :section_category_id
+
+      def show
+        @theme = services.fetch_theme.call
+      end
+
+      private
+
+      def section_category_id
+        params[:category_id].presence || @theme.section_categories.first.id
+      end
+    end
+  end
+end

data/app/controllers/maglev/api/assets_controller.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Maglev
+  module API
+    class AssetsController < ::Maglev::APIController
+      include ::ActiveStorage::SetCurrent
+
+      def index
+        @assets = resources.search(
+          params[:query], params[:asset_type], params[:page], params[:per_page]
+        )
+      end
+
+      def show
+        @asset = resources.find(params[:id])
+      end
+
+      def create
+        asset = resources.create!(asset_params)
+        head :created, location: api_asset_path(asset), maglev_asset_id: asset.id
+      end
+
+      def update
+        resources.find(params[:id]).update!(asset_params)
+        head :ok
+      end
+
+      def destroy
+        resources.find(params[:id]).destroy!
+        head :no_content
+      end
+
+      private
+
+      def asset_params
+        params.require(:asset).permit(:file)
+      end
+
+      def resources
+        ::Maglev::Asset
+      end
+    end
+  end
+end

data/app/controllers/maglev/api/collection_items_controller.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Maglev
+  module API
+    class CollectionItemsController < ::Maglev::APIController
+      def index
+        @items = services.fetch_collection_items.call(
+          collection_id: params[:collection_id],
+          keyword: params[:q]
+        )
+      end
+    end
+  end
+end

data/app/controllers/maglev/api/page_clones_controller.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Maglev
+  module API
+    class PageClonesController < ::Maglev::APIController
+      def create
+        page = clone_page(resources.find(params[:page_id]))
+        head :created, location: api_page_path(page)
+      end
+
+      private
+
+      def clone_page(page)
+        services.clone_page.call(page: page)
+      end
+
+      def resources
+        ::Maglev::Page
+      end
+    end
+  end
+end

data/app/controllers/maglev/api/pages_controller.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Maglev
+  module API
+    class PagesController < ::Maglev::APIController
+      def index
+        @pages = services.search_pages.call(q: params[:q], content_locale: content_locale,
+                                            default_locale: default_content_locale)
+      end
+
+      def show
+        @page = services.search_pages.call(id: params[:id], content_locale: content_locale,
+                                           default_locale: default_content_locale)
+        head :not_found if @page.nil?
+      end
+
+      def create
+        page = persist!(resources.new)
+        head :created, location: api_page_path(page)
+      end
+
+      def destroy
+        resources.destroy(params[:id])
+        head :no_content
+      end
+
+      def update
+        page = resources.find(params[:id])
+        persist!(page)
+        head :ok, page_lock_version: page.lock_version
+      end
+
+      private
+
+      def page_params
+        params.require(:page).permit(:title, :path,
+                                     :seo_title, :meta_description,
+                                     :og_title, :og_description, :og_image_url,
+                                     :visible, :lock_version).tap do |whitelisted|
+          whitelisted[:sections] = params[:page].to_unsafe_hash[:sections] unless params.dig(:page, :sections).nil?
+        end
+      end
+
+      def site_params
+        lock_version = params.dig(:site, :lock_version)
+        sections = params[:site].to_unsafe_hash[:sections] unless params.dig(:site, :sections).nil?
+        style = params.dig(:site, :style)
+        (lock_version && sections ? { lock_version: lock_version, sections: sections } : {}).merge(style: style)
+      end
+
+      def persist!(page)
+        services.persist_page.call(
+          page: page,
+          page_attributes: page_params,
+          site: maglev_site,
+          site_attributes: site_params
+        )
+      end
+
+      def resources
+        ::Maglev::Page
+      end
+    end
+  end
+end

data/app/controllers/maglev/api/publications_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Maglev
+  module API
+    class PublicationsController < ::Maglev::APIController
+      def show
+        raise 'NOT IMPLEMENTED'
+      end
+
+      def create
+        raise 'NOT IMPLEMENTED'
+      end
+    end
+  end
+end