cms42 0.1.0

data/app/models/cms/api_key.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Cms
+  class ApiKey < ApplicationRecord
+    self.table_name = "cms_api_keys"
+
+    belongs_to :site, class_name: "Cms::Site", inverse_of: :api_keys
+
+    validates :name, presence: true
+    validates :token, presence: true, uniqueness: true
+
+    before_validation :generate_token, on: :create
+
+    scope :active, -> { where(active: true) }
+    scope :ordered, -> { order(:name) }
+
+    def touch_last_used!
+      update_column(:last_used_at, Time.current)
+    end
+
+    private
+
+    def generate_token
+      self.token = SecureRandom.hex(32)
+    end
+  end
+end

data/app/models/cms/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Cms
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/cms/document.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Cms
+  class Document < ApplicationRecord
+    self.table_name = "cms_documents"
+
+    WORD_CONTENT_TYPES = [
+      "application/msword",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      "application/vnd.ms-excel",
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      "application/vnd.ms-powerpoint",
+      "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    ].freeze
+
+    PERMITTED_CONTENT_TYPES = [
+      "application/pdf",
+      "image/png",
+      "image/jpeg",
+      "image/tiff",
+      "text/plain",
+      "text/csv",
+      "application/zip",
+      "application/x-zip-compressed"
+    ] + WORD_CONTENT_TYPES
+
+    belongs_to :site, class_name: "Cms::Site", inverse_of: :documents
+    has_one_attached :file
+
+    validates :title, :file, presence: true
+    validate :file_must_be_a_supported_document
+
+    scope :ordered, -> { order(:title) }
+
+    def display_title
+      title
+    end
+
+    private
+
+    def file_must_be_a_supported_document
+      return unless file.attached?
+      return if PERMITTED_CONTENT_TYPES.include?(file.blob.content_type)
+
+      errors.add(:file, I18n.t("cms.errors.document.invalid_file_type", default: "must be a supported document file"))
+    end
+  end
+end

data/app/models/cms/form_field.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Cms
+  class FormField < ApplicationRecord
+    self.table_name = "cms_form_fields"
+
+    KINDS = %w[text email textarea select checkbox].freeze
+
+    belongs_to :page, class_name: "Cms::Page", inverse_of: :form_fields
+
+    validates :kind, presence: true, inclusion: { in: KINDS }
+    validates :label, :field_name, presence: true
+    validates :field_name, uniqueness: { scope: :page_id },
+                           format: { with: /\A[a-z0-9_]+\z/,
+                                     message: ->(*) { I18n.t("cms.errors.form_field.invalid_field_name") } }
+
+    scope :ordered, -> { order(:position, :id) }
+
+    def select?
+      kind == "select"
+    end
+
+    def parsed_options
+      Array(options)
+    end
+  end
+end

data/app/models/cms/form_submission.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Cms
+  class FormSubmission < ApplicationRecord
+    self.table_name = "cms_form_submissions"
+
+    belongs_to :page, class_name: "Cms::Page", inverse_of: :form_submissions
+
+    validates :data, presence: true
+    validate :contains_response_data
+    validate :required_fields_present
+
+    scope :recent, -> { order(created_at: :desc) }
+
+    def self.to_csv(submissions, fields)
+      require "csv"
+
+      CSV.generate(headers: true) do |csv|
+        csv << ([I18n.t("cms.admin.form_submissions.index.submitted_at")] + fields.map(&:label))
+        submissions.each do |sub|
+          csv << ([I18n.l(sub.created_at, format: :cms_csv_datetime)] + fields.map { |f| sub.data[f.field_name] })
+        end
+      end
+    end
+
+    private
+
+    def contains_response_data
+      values = data.to_h.values.reject { |value| value.to_s.in?(%w[0]) }
+      errors.add(:base, I18n.t("cms.errors.form_submission.blank")) if values.all?(&:blank?)
+    end
+
+    def required_fields_present
+      page.form_fields.ordered.select(&:required?).each do |field|
+        value = data.to_h[field.field_name]
+        next unless value.to_s.blank? || value.to_s == "0"
+
+        errors.add(field.field_name.to_sym, I18n.t("cms.errors.form_submission.required", label: field.label))
+      end
+    end
+  end
+end

data/app/models/cms/image.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Cms
+  class Image < ApplicationRecord
+    self.table_name = "cms_images"
+
+    PERMITTED_CONTENT_TYPES = [
+      "image/jpeg",
+      "image/png",
+      "image/webp",
+      "image/gif",
+      "image/svg+xml",
+      "image/tiff"
+    ].freeze
+
+    belongs_to :site, class_name: "Cms::Site", inverse_of: :images
+    has_one_attached :file
+    has_many :section_images,
+             class_name: "Cms::SectionImage",
+             foreign_key: :image_id,
+             inverse_of: :image,
+             dependent: :destroy
+
+    has_many :image_translations,
+             class_name: "Cms::ImageTranslation",
+             foreign_key: :image_id,
+             inverse_of: :image,
+             dependent: :destroy
+
+    accepts_nested_attributes_for :image_translations
+
+    has_one :localised, -> { where(locale: I18n.locale.to_s) },
+            class_name: "Cms::ImageTranslation",
+            foreign_key: :image_id,
+            inverse_of: :image
+
+    delegate :alt_text, :caption, to: :localised, allow_nil: true
+
+    validates :title, :file, presence: true
+    validate :file_must_be_an_image
+
+    scope :ordered, -> { order(created_at: :desc) }
+
+    def display_title
+      title.presence || file.filename.to_s
+    end
+
+    def variant(dimensions)
+      file.variant(resize_to_limit: dimensions.split("x").map(&:to_i))
+    end
+
+    private
+
+    def file_must_be_an_image
+      return unless file.attached?
+      return if PERMITTED_CONTENT_TYPES.include?(file.blob.content_type)
+
+      errors.add(:file, I18n.t("cms.errors.image.invalid_file_type", default: "must be a valid image file"))
+    end
+  end
+end

data/app/models/cms/image_translation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Cms
+  class ImageTranslation < ApplicationRecord
+    self.table_name = "cms_image_translations"
+
+    belongs_to :image,
+               class_name: "Cms::Image",
+               inverse_of: :image_translations
+
+    validates :locale, :alt_text, presence: true
+    validates :locale, uniqueness: { scope: :image_id }
+
+    before_validation :normalize_locale
+
+    private
+
+    def normalize_locale
+      self.locale = locale.to_s.downcase.presence
+    end
+  end
+end

data/app/models/cms/page.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Cms
+  class Page < ApplicationRecord
+    include ::Discard::Model
+
+    self.table_name = "cms_pages"
+
+    MAX_DEPTH = 10
+
+    module TemplateRegistry
+      class << self
+        def register(key)
+          normalized = key.to_s.parameterize.underscore
+          return if normalized.blank?
+
+          registered[normalized] = true
+        end
+
+        def registered_keys
+          registered.keys
+        end
+
+        private
+
+        def registered
+          @registered ||= begin
+            defaults = %w[standard landing form custom]
+            defaults.index_with { true }
+          end
+        end
+      end
+    end
+
+    has_one_attached :hero_image
+    has_many_attached :media_files
+
+    belongs_to :site,
+               class_name: "Cms::Site",
+               inverse_of: :pages
+
+    belongs_to :parent,
+               class_name: "Cms::Page",
+               optional: true,
+               inverse_of: :subpages
+
+    has_many :subpages,
+             class_name: "Cms::Page",
+             foreign_key: :parent_id,
+             dependent: :nullify,
+             inverse_of: :parent
+
+    has_many :page_translations,
+             class_name: "Cms::PageTranslation",
+             foreign_key: :page_id,
+             inverse_of: :page,
+             dependent: :destroy
+
+    accepts_nested_attributes_for :page_translations
+
+    has_one :localised, -> { where(locale: I18n.locale.to_s) },
+            class_name: "Cms::PageTranslation",
+            foreign_key: :page_id,
+            inverse_of: :page
+
+    delegate :title, :seo_title, :seo_description,
+             to: :localised, allow_nil: true
+
+    has_many :page_sections,
+             class_name: "Cms::PageSection",
+             foreign_key: :page_id,
+             inverse_of: :page,
+             dependent: :destroy
+
+    has_many :sections,
+             through: :page_sections,
+             source: :section
+
+    has_many :form_fields,
+             class_name: "Cms::FormField",
+             foreign_key: :page_id,
+             inverse_of: :page,
+             dependent: :destroy
+
+    has_many :form_submissions,
+             class_name: "Cms::FormSubmission",
+             foreign_key: :page_id,
+             inverse_of: :page,
+             dependent: :destroy
+
+    enum :status,
+         {
+           draft: "draft",
+           published: "published",
+           archived: "archived"
+         },
+         prefix: true
+
+    validates :slug, presence: true
+    validates :slug, uniqueness: { scope: :site_id }
+    validates :template_key, presence: true, inclusion: { in: ->(_) { template_keys } }
+    validates :depth, numericality: { less_than_or_equal_to: MAX_DEPTH }
+    validate :published_pages_require_sections
+
+    before_create :generate_preview_token
+    before_validation :set_slug
+    before_validation :normalize_home_slug
+    before_validation :set_defaults
+    before_validation :compute_depth
+    before_save :ensure_single_home_page, if: -> { home? && will_save_change_to_home? }
+    after_commit :fire_webhooks_on_status_change, on: %i[create update]
+    after_save :update_descendant_depths, if: :saved_change_to_parent_id?
+
+    scope :ordered, -> { order(:position, :id) }
+    scope :root, -> { where(parent_id: nil) }
+    scope :published, -> { where(status: "published") }
+    scope :header_nav, -> { where(show_in_header: true).where.not(nav_group: "none").order(:nav_order, :position, :id) }
+    scope :footer_nav, lambda {
+      where(show_in_footer: true).where.not(nav_group: "none").order(:footer_order, :position, :id)
+    }
+    scope :search, lambda { |q|
+      joins(:page_translations)
+        .where(
+          "lower(unaccent(cms_page_translations.title)) ilike lower(unaccent(?)) OR " \
+          "lower(unaccent(cms_pages.slug)) ilike lower(unaccent(?))",
+          "%#{q}%", "%#{q}%"
+        ).distinct
+    }
+    scope :search_ordered, ->(q) { search(q).ordered }
+
+    def self.template_keys
+      TemplateRegistry.registered_keys
+    end
+
+    def display_title
+      title.presence || slug.to_s.humanize
+    end
+
+    def display_meta_title
+      seo_title.presence || display_title
+    end
+
+    def ancestors
+      parent ? parent.ancestors + [parent] : []
+    end
+
+    def descendants
+      subpages.flat_map { |p| [p] + p.descendants }
+    end
+
+    def ordered_page_sections
+      page_sections.ordered.includes(:section)
+    end
+
+    def public_path_segments
+      return [] if home?
+
+      (ancestors + [self]).reject(&:home?).map(&:slug)
+    end
+
+    def public_path
+      public_path_segments.join("/")
+    end
+
+    private
+
+    def compute_depth
+      self.depth = parent ? (parent.depth + 1) : 0
+    end
+
+    def update_descendant_depths(parent_depth = depth)
+      subpages.find_each do |child|
+        child.update_column(:depth, parent_depth + 1)
+        child.update_descendant_depths(parent_depth + 1)
+      end
+    end
+
+    def fire_webhooks_on_status_change
+      return unless saved_change_to_status?
+
+      event = case status
+              when "published" then "page.published"
+              when "archived"  then "page.unpublished"
+              end
+      return if event.blank?
+
+      site.webhooks.active.each do |webhook|
+        Cms::DeliverWebhookJob.perform_later(webhook.id, event, { "page_id" => id, "slug" => slug })
+      end
+    rescue StandardError
+      # Webhook delivery failures must never break page saves
+    end
+
+    def set_slug
+      default_locale = site.default_locale.presence || I18n.default_locale.to_s
+      translation_title = page_translations.find { |t| t.locale == default_locale }&.title if page_translations.loaded?
+
+      self.slug = slug.to_s.parameterize if slug.present?
+      self.slug = translation_title.to_s.parameterize if slug.blank? && translation_title.present?
+    end
+
+    def normalize_home_slug
+      self.slug = "home" if home?
+    end
+
+    def set_defaults
+      self.template_key = "standard" if template_key.blank?
+      self.nav_group = "main" if nav_group.blank?
+    end
+
+    def generate_preview_token
+      self.preview_token ||= SecureRandom.urlsafe_base64(32)
+    end
+
+    def ensure_single_home_page
+      site.pages.where.not(id: id).where(home: true).find_each do |page|
+        page.update!(home: false)
+      end
+    end
+
+    def published_pages_require_sections
+      return unless status_published?
+      return if page_sections.loaded? ? page_sections.reject(&:marked_for_destruction?).any? : page_sections.exists?
+
+      errors.add(:base, I18n.t("cms.errors.page.sections_required"))
+    end
+  end
+end

data/app/models/cms/page_section.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Cms
+  class PageSection < ApplicationRecord
+    self.table_name = "cms_page_sections"
+
+    belongs_to :page, class_name: "Cms::Page", inverse_of: :page_sections
+    belongs_to :section, class_name: "Cms::Section", inverse_of: :page_sections
+
+    validates :section_id, uniqueness: { scope: :page_id }
+    validate :section_site_matches_page
+    validate :global_sections_cannot_become_orphaned, on: :destroy
+
+    scope :ordered, -> { order(:position, :id) }
+
+    after_destroy :destroy_orphaned_section
+
+    private
+
+    def section_site_matches_page
+      return unless page && section
+      return if page.site_id == section.site_id
+
+      errors.add(:section, :invalid)
+    end
+
+    def global_sections_cannot_become_orphaned
+      return unless section&.global?
+      return if section.page_sections.where.not(id: id).exists?
+
+      errors.add(:base, I18n.t("cms.errors.section.global_section_requires_attachment"))
+      throw :abort
+    end
+
+    def destroy_orphaned_section
+      return unless Cms.config.auto_destroy_orphaned_sections
+      return if section.global?
+      return if section.page_sections.exists?
+
+      section.destroy
+    end
+  end
+end

data/app/models/cms/page_translation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Cms
+  class PageTranslation < ApplicationRecord
+    self.table_name = "cms_page_translations"
+
+    belongs_to :page,
+               class_name: "Cms::Page",
+               inverse_of: :page_translations
+
+    validates :locale, :title, presence: true
+    validates :locale, uniqueness: { scope: :page_id }
+
+    before_validation :normalize_locale
+
+    private
+
+    def normalize_locale
+      self.locale = locale.to_s.downcase.presence
+    end
+  end
+end

data/app/models/cms/section/block_base.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Cms
+  class Section
+    class BlockBase
+      # Each subclass gets its own independent schema array
+      def self.inherited(subclass)
+        super
+        subclass.instance_variable_set(:@_settings_schema, [])
+      end
+
+      def self.settings_field(name, type:, required: false, default: nil, options: nil)
+        @_settings_schema ||= []
+        @_settings_schema << {
+          name: name.to_s,
+          type: type,
+          required: required,
+          default: default,
+          options: options
+        }.compact
+      end
+
+      def self.settings_schema
+        @_settings_schema || []
+      end
+
+      def self.kind
+        raise NotImplementedError, "#{self} must define .kind"
+      end
+    end
+  end
+end

data/app/models/cms/section/blocks/call_to_action_block.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cms
+  class Section
+    module Blocks
+      class CallToActionBlock < BlockBase
+        def self.kind = "cta"
+
+        settings_field :button_text, type: :string, required: true
+        settings_field :button_url, type: :url,    required: true
+        settings_field :alignment,  type: :select, default: "center",
+                                    options: %w[left center right]
+      end
+    end
+  end
+end

data/app/models/cms/section/blocks/hero_block.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Cms
+  class Section
+    module Blocks
+      class HeroBlock < BlockBase
+        def self.kind = "hero"
+
+        settings_field :background_color, type: :color, default: "#ffffff"
+        settings_field :cta_url,          type: :url
+      end
+    end
+  end
+end

data/app/models/cms/section/blocks/image_block.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Cms
+  class Section
+    module Blocks
+      class ImageBlock < BlockBase
+        def self.kind = "image"
+
+        settings_field :image_ids, type: :array
+      end
+    end
+  end
+end

data/app/models/cms/section/blocks/rich_text_block.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Cms
+  class Section
+    module Blocks
+      class RichTextBlock < BlockBase
+        def self.kind = "rich_text"
+        # No settings — title and content come from SectionTranslation
+      end
+    end
+  end
+end

data/app/models/cms/section/kind_registry.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Cms
+  class Section
+    module KindRegistry
+      BUILT_IN_KINDS = %w[rich_text image hero cta].freeze
+
+      class UnknownKindError < StandardError; end
+
+      @registry = {}
+
+      class << self
+        # Register a section kind.
+        #
+        # @param kind [String, Symbol]
+        # @param partial [String, nil] override the default partial path
+        # @param block_class [Class, nil] block class that defines settings_schema
+        def register(kind, partial: nil, block_class: nil)
+          @registry[kind.to_s] = {
+            partial: partial.presence || "cms/sections/kinds/#{kind}",
+            block_class: block_class
+          }
+        end
+
+        # @param kind [String]
+        # @return [String] partial path
+        # @raise [Cms::Section::KindRegistry::UnknownKindError]
+        def partial_for(kind)
+          entry_for(kind)[:partial]
+        end
+
+        # @param kind [String]
+        # @return [Class, nil] block class or nil if not set
+        def block_class_for(kind)
+          entry_for(kind)[:block_class]
+        end
+
+        # @return [Array<String>]
+        def registered_kinds
+          @registry.keys
+        end
+
+        # @param kind [String, Symbol]
+        # @return [Boolean]
+        def registered?(kind)
+          @registry.key?(kind.to_s)
+        end
+
+        # For testing — resets to an empty registry
+        def reset!
+          @registry = {}
+        end
+
+        private
+
+        def entry_for(kind)
+          @registry.fetch(kind.to_s) do
+            raise UnknownKindError,
+                  "No renderer registered for section kind: #{kind.inspect}. " \
+                  "Registered kinds: #{@registry.keys.inspect}"
+          end
+        end
+      end
+    end
+  end
+end