cms42 0.1.0

data/app/controllers/cms/public/form_submissions_controller.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Cms
+  module Public
+    class FormSubmissionsController < BaseController
+      include Cms::SiteResolvable
+      include Cms::Public::PageRendering
+      include Cms::Public::PagePaths
+
+      def create
+        @site = find_site!
+        @page = @site.published_pages.includes(:form_fields, :page_translations, :localised,
+                                               { page_sections: :section },
+                                               { hero_image_attachment: :blob }).find(params[:page_id])
+        @fields = @page.form_fields.ordered
+        data = build_submission_data
+
+        @submission = @page.form_submissions.build(
+          data: data,
+          ip_address: request.remote_ip
+        )
+
+        if @submission.save
+          notify_by_email(@submission)
+          redirect_back(
+            fallback_location: public_site_page_path_for(@site, @page),
+            notice: t("cms.notices.form_submission_sent")
+          )
+        else
+          I18n.with_locale(@site.default_locale) do
+            assign_public_page(site: @site, page: @page)
+            render template: "cms/public/pages/show", status: :unprocessable_content
+          end
+        end
+      rescue ActiveRecord::RecordNotFound
+        render plain: t("cms.errors.page_not_found"), status: :not_found
+      end
+
+      private
+
+      def build_submission_data
+        @fields.to_h do |field|
+          [field.field_name, normalized_submission_value(field)]
+        end
+      end
+
+      def normalized_submission_value(field)
+        params.dig(:submission, field.field_name)
+      end
+
+      def notify_by_email(submission)
+        return unless Cms.config.form_submission_email
+
+        email = Cms.config.form_submission_email.call(@page)
+        return if email.blank?
+
+        Cms::FormSubmissionMailer.notify(submission, email).deliver_later
+      rescue StandardError
+        # Mailer failures must never break form submission
+      end
+    end
+  end
+end

data/app/controllers/cms/public/previews_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Cms
+  module Public
+    class PreviewsController < BaseController
+      include Cms::SiteResolvable
+      include Cms::Public::PageRendering
+      include Cms::Public::PagePaths
+
+      def show
+        page = Cms::Page.kept.includes(:site).find_by!(preview_token: params[:preview_token])
+        site = page.site
+
+        I18n.with_locale(site.default_locale) do
+          assign_public_page(site: site, page: page)
+          render template: "cms/public/pages/show"
+        end
+      end
+    end
+  end
+end

data/app/controllers/cms/public/sites_controller.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Cms
+  module Public
+    class SitesController < BaseController
+      include Cms::SiteResolvable
+      include Cms::Public::PageRendering
+      include Cms::Public::PagePaths
+
+      def show
+        site = find_site!
+        result = find_page_for_show!(site)
+
+        return render_not_found unless result
+
+        I18n.with_locale(result.locale) do
+          assign_public_page(site: site, page: result.page)
+          render template: "cms/public/pages/show"
+        end
+      end
+
+      private
+
+      def find_page_for_show!(site)
+        page_resolver_class.resolve(
+          site: site,
+          slug: params[:slug],
+          locale: I18n.locale.to_s
+        )
+      end
+
+      def render_not_found
+        render plain: t("cms.errors.page_not_found"), status: :not_found
+      end
+    end
+  end
+end

data/app/controllers/concerns/cms/admin/page_scoped_sections.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Cms
+  module Admin
+    module PageScopedSections
+      extend ActiveSupport::Concern
+
+      private
+
+      def set_page
+        @page = current_site.pages.find(params[:page_id])
+      end
+
+      def page_scoped_request?
+        params[:page_id].present?
+      end
+
+      def turbo_page_scoped_request?
+        page_scoped_request? && (turbo_frame_request? || request.format.turbo_stream?)
+      end
+
+      def attach_to_page!
+        @page.page_sections.create!(section: @section, position: next_position)
+      end
+
+      def next_position
+        @page.page_sections.maximum(:position).to_i + 1
+      end
+
+      def load_page_show_context
+        @translation_locale = requested_locale
+        @subpages = @page.subpages.sort_by { |page| [page.position || 0, page.id] }
+        @page_sections = @page.page_sections.ordered.includes(:section)
+        @available_sections = current_site.sections
+                                          .kept
+                                          .global
+                                          .where.not(id: @page.section_ids)
+                                          .ordered
+      end
+    end
+  end
+end

data/app/controllers/concerns/cms/current_site_resolver.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Cms
+  module CurrentSiteResolver
+    extend ActiveSupport::Concern
+
+    private
+
+    def configured_current_site
+      resolver = Cms.config.current_site_resolver
+      site = resolver.call(self) if resolver
+      return site if site.is_a?(Cms::Site)
+
+      nil
+    end
+  end
+end

data/app/controllers/concerns/cms/public/page_paths.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Cms
+  module Public
+    module PagePaths
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :public_site_path_for, :public_site_page_path_for
+      end
+
+      private
+
+      def routed_without_site_slug?
+        params[:site_slug].blank? && (request.headers["X-CMS-SITE-SLUG"].present? || request.subdomains.first.present?)
+      end
+
+      def public_site_path_for(site)
+        routed_without_site_slug? ? current_site_path : site_path(site.slug)
+      end
+
+      def public_site_page_path_for(site, page)
+        return public_site_path_for(site) if page.home?
+
+        page_path = page.public_path
+
+        routed_without_site_slug? ? current_site_page_path(page_path) : site_page_path(site.slug, page_path)
+      end
+    end
+  end
+end

data/app/controllers/concerns/cms/public/page_rendering.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Cms
+  module Public
+    module PageRendering
+      extend ActiveSupport::Concern
+
+      private
+
+      def assign_public_page(site:, page:)
+        ctx = Cms::PublicPageContext.build(site: site, page: page)
+
+        @site              = ctx.site
+        @page              = ctx.page
+        @header_nav_items  = ctx.header_nav_items
+        @footer_pages      = ctx.footer_pages
+        @sections          = ctx.sections
+        @form_fields       = ctx.form_fields
+        @submission        = ctx.submission if @submission.nil?
+      end
+    end
+  end
+end

data/app/controllers/concerns/cms/site_resolvable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Cms
+  module SiteResolvable
+    extend ActiveSupport::Concern
+    include Cms::CurrentSiteResolver
+
+    private
+
+    def find_site!
+      return @resolved_site if defined?(@resolved_site) && @resolved_site
+      return configured_current_site if configured_current_site
+
+      Cms::Site.live.find_by!(slug: resolved_site_slug!)
+    end
+
+    def resolved_site_slug!
+      slug = params[:site_slug].presence ||
+             request.headers["X-CMS-SITE-SLUG"].presence ||
+             request.subdomains.first.presence
+      normalized = slug.to_s.parameterize
+      raise ActiveRecord::RecordNotFound, I18n.t("cms.errors.site_slug_not_provided") if normalized.blank?
+
+      normalized
+    end
+  end
+end

data/app/helpers/cms/admin/pages_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Cms
+  module Admin
+    module PagesHelper
+      # Flatten a tree of pages (already loaded with subpages) into [page, depth] pairs.
+      def flat_page_tree(pages, depth: 0, result: [])
+        pages.each do |page|
+          result << [page, depth]
+          flat_page_tree(Array(page.subpages), depth: depth + 1, result: result) if page.subpages.loaded?
+        end
+        result
+      end
+
+      # Returns breadcrumb array for a page: [ancestor, ..., page]
+      def breadcrumbs_for(page)
+        page.ancestors + [page]
+      end
+
+      # Translation completeness: { "en" => :complete, "fr" => :missing }
+      def translation_completeness(page)
+        I18n.available_locales.each_with_object({}) do |locale, hash|
+          translation = page.page_translations.find { |t| t.locale == locale.to_s }
+          hash[locale.to_s] = translation&.title.present? ? :complete : :missing
+        end
+      end
+    end
+  end
+end

data/app/helpers/cms/admin/sections_helper.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Cms
+  module Admin
+    module SectionsHelper
+      # Renders a form field for a block settings field definition.
+      #
+      # @param form [ActionView::Helpers::FormBuilder]
+      # @param field [Hash] field definition from BlockBase.settings_schema
+      def render_settings_field(form, field, site: nil)
+        name = field[:name]
+
+        content_tag(:div, class: "cms-form__field") do
+          concat form.label("settings_#{name}", cms_section_setting_label(name), class: "cms-form__label")
+          concat settings_input(form, field, site: site)
+          if field[:type] == :image
+            concat image_library_actions
+            concat image_library_hint(site) if site&.images&.none?
+          end
+        end
+      end
+
+      def cms_section_image_options(site)
+        return [] unless site
+
+        site.images.ordered.map { |image| [image.display_title, image.id] }
+      end
+
+      private
+
+      def settings_input(form, field, site:)
+        name = field[:name]
+
+        case field[:type]
+        when :url
+          form.url_field "settings[#{name}]", input_options(form, name)
+        when :color
+          form.color_field "settings[#{name}]", input_options(form, name, default: field[:default])
+        when :boolean
+          form.check_box "settings[#{name}]", { class: "cms-checkbox" }, "true", "false"
+        when :select
+          form.select "settings[#{name}]",
+                      select_options(field),
+                      { selected: form.object.settings[name] || field[:default] },
+                      class: "cms-input"
+        when :image
+          form.select "settings[#{name}]",
+                      cms_section_image_options(site),
+                      {
+                        include_blank: t("cms.admin.sections.form.select_image"),
+                        selected: form.object.settings[name]
+                      },
+                      class: "cms-input"
+        else
+          form.text_field "settings[#{name}]", input_options(form, name)
+        end
+      end
+
+      def input_options(form, name, default: nil)
+        { class: "cms-input", value: form.object.settings[name] || default }
+      end
+
+      def select_options(field)
+        field[:options].map { |option| [cms_section_setting_option_label(field[:name], option), option] }
+      end
+
+      def image_library_hint(site)
+        return "".html_safe unless site&.images&.none?
+
+        content_tag(:p, t("cms.admin.sections.form.image_library_empty"), class: "cms-form__hint")
+      end
+
+      def image_library_actions
+        content_tag(:p, class: "cms-form__hint") do
+          safe_join(
+            [
+              link_to(t("cms.admin.sections.form.manage_images"), admin_images_path),
+              " ",
+              link_to(t("cms.admin.sections.form.upload_image"), new_admin_image_path)
+            ]
+          )
+        end
+      end
+    end
+  end
+end

data/app/helpers/cms/admin/sites_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Cms
+  module Admin
+    module SitesHelper
+    end
+  end
+end

data/app/helpers/cms/application_helper.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Cms
+  module ApplicationHelper
+    def cms_attachment_path(attachment)
+      return unless attachment.attached?
+
+      main_app.rails_blob_path(attachment, only_path: true)
+    end
+
+    def cms_yes_no(value)
+      t(value ? "cms.shared.yes" : "cms.shared.no")
+    end
+
+    def cms_date(value)
+      l(value.to_date, format: :cms_date)
+    end
+
+    def cms_datetime(value)
+      l(value, format: :cms_datetime)
+    end
+
+    def cms_page_template_label(key)
+      t("cms.page_templates.#{key}")
+    end
+
+    def cms_page_status_label(key)
+      t("cms.page_statuses.#{key}")
+    end
+
+    def cms_form_field_kind_label(key)
+      t("cms.form_field_kinds.#{key}")
+    end
+
+    def cms_section_kind_label(key)
+      t("cms.section_kinds.#{key}")
+    end
+
+    def cms_webhook_event_label(key)
+      t("cms.webhook_events.#{key.tr('.', '_')}")
+    end
+
+    def cms_section_setting_label(name)
+      t("cms.section_settings.labels.#{name}")
+    end
+
+    def cms_section_setting_option_label(name, option)
+      t("cms.section_settings.options.#{name}.#{option}")
+    end
+  end
+end

data/app/helpers/cms/media_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Cms
+  module MediaHelper
+    def cms_image_tag(image, rendition: nil, **)
+      return "" unless image&.file&.attached?
+
+      if rendition && Cms.config.image_renditions&.key?(rendition)
+        dimensions = Cms.config.image_renditions[rendition]
+        width, height = dimensions.split("x").map(&:to_i)
+        variant = image.file.variant(resize_to_limit: [width, height]).processed
+        image_tag(main_app.rails_representation_path(variant, only_path: true),
+                  alt: image.alt_text.presence || image.display_title,
+                  **)
+      else
+        image_tag(main_app.rails_blob_path(image.file, only_path: true),
+                  alt: image.alt_text.presence || image.display_title,
+                  **)
+      end
+    end
+
+    def cms_document_url(document)
+      return nil unless document&.file&.attached?
+
+      url_for(document.file)
+    end
+  end
+end

data/app/helpers/cms/pages_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cms
+  module PagesHelper
+    def render_page_template(page)
+      render partial: cms_page_template_partial(page)
+    end
+
+    def cms_page_template_partial(page)
+      template = "cms/public/pages/templates/#{page.template_key}"
+      return template if lookup_context.exists?(template, [], true)
+
+      "cms/public/pages/templates/standard"
+    end
+  end
+end

data/app/helpers/cms/sections_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Cms
+  module SectionsHelper
+    def cms_sections(kind:, site: nil)
+      target_site = site || (defined?(@site) ? @site : nil)
+      return Cms::Section.none unless target_site
+
+      target_site.sections.enabled.by_kind(kind).includes(:translations,
+                                                          section_images: { image: { file_attachment: :blob } }).ordered
+    end
+
+    # Renders the partial registered for the section's kind.
+    # In non-production, renders an error notice for unknown kinds.
+    # In production, raises so the error is surfaced properly.
+    def render_section(section)
+      partial = Cms::Section::KindRegistry.partial_for(section.kind)
+      render partial, section: section
+    rescue Cms::Section::KindRegistry::UnknownKindError => e
+      raise e if Rails.env.production?
+
+      content_tag(:div, e.message, class: "cms-section--unknown", style: "color:red;padding:1em;border:1px solid red;")
+    end
+  end
+end

data/app/helpers/cms/sites_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Cms
+  module SitesHelper
+    def site_favicon_tag(site)
+      return unless site.logo.attached?
+
+      favicon_link_tag(cms_attachment_path(site.logo))
+    end
+  end
+end

data/app/javascript/cms/controllers/sortable_controller.js

@@ -0,0 +1,38 @@
+import { Controller } from "@hotwired/stimulus"
+import Sortable from "sortablejs"
+
+export default class extends Controller {
+  static values = {
+    url: String,
+    handle: { type: String, default: ".cms-section-item__handle" }
+  }
+
+  connect() {
+    this.sortable = Sortable.create(this.element, {
+      handle: this.handleValue,
+      animation: 150,
+      onEnd: this.persistOrder.bind(this)
+    })
+  }
+
+  disconnect() {
+    this.sortable?.destroy()
+  }
+
+  persistOrder() {
+    const ids = Array.from(this.element.querySelectorAll("[data-page-section-id]"))
+      .map(el => el.dataset.pageSectionId)
+
+    const body = new URLSearchParams()
+    ids.forEach(id => body.append("page_section_ids[]", id))
+
+    fetch(this.urlValue, {
+      method: "PATCH",
+      headers: {
+        "X-CSRF-Token": document.querySelector("meta[name=csrf-token]")?.content,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: body.toString()
+    })
+  }
+}

data/app/jobs/cms/application_job.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Cms
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/cms/deliver_webhook_job.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+
+module Cms
+  class DeliverWebhookJob < ApplicationJob
+    queue_as :default
+
+    def perform(webhook_id, event, payload)
+      webhook = Cms::Webhook.find_by(id: webhook_id)
+      return unless deliverable?(webhook, event)
+
+      response = build_http_client(webhook.url).request(build_request(webhook, event, payload))
+      record_delivery(webhook, event, response: response)
+    rescue StandardError => e
+      record_delivery(webhook, event, error: e) if webhook
+    end
+
+    private
+
+    def deliverable?(webhook, event)
+      webhook&.active? && webhook.events.include?(event)
+    end
+
+    def build_http_client(url)
+      uri = URI.parse(url)
+
+      Net::HTTP.new(uri.host, uri.port).tap do |http|
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 5
+        http.read_timeout = 10
+      end
+    end
+
+    def build_request(webhook, event, payload)
+      body = request_body(payload, event)
+      uri = URI.parse(webhook.url)
+
+      Net::HTTP::Post.new(uri.request_uri).tap do |request|
+        request["Content-Type"] = "application/json"
+        request["X-CMS-Event"] = event
+        request["X-CMS-Signature"] = sign(body, webhook.secret) if webhook.secret.present?
+        request.body = body
+      end
+    end
+
+    def request_body(payload, event)
+      JSON.generate(payload.merge("event" => event, "timestamp" => Time.current.iso8601))
+    end
+
+    def record_delivery(webhook, event, response: nil, error: nil)
+      webhook.deliveries.create!(
+        event: event,
+        response_code: response&.code&.to_i,
+        response_body: response&.body.to_s.truncate(2000),
+        success: error.nil? && response&.code.to_i.between?(200, 299),
+        error_message: error&.message&.truncate(500)
+      )
+    end
+
+    def sign(body, secret)
+      "sha256=#{OpenSSL::HMAC.hexdigest('SHA256', secret, body)}"
+    end
+  end
+end

data/app/mailers/cms/application_mailer.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cms
+  class ApplicationMailer < ActionMailer::Base
+    default from: -> { Cms.config.mailer_from.presence || "noreply@example.com" }
+    layout "mailer"
+    helper Cms::ApplicationHelper
+  end
+end

data/app/mailers/cms/form_submission_mailer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cms
+  class FormSubmissionMailer < ApplicationMailer
+    def notify(submission, recipient_email)
+      @submission = submission
+      @page = submission.page
+      @fields = @page.form_fields.ordered
+
+      mail(
+        to: recipient_email,
+        subject: I18n.t("cms.mailers.form_submission.subject", page_title: @page.display_title)
+      )
+    end
+  end
+end