macron-cms 3.0.0 → 5.0.0

data/app/controllers/macron/cms/api/v1/articles_controller.rb

@@ -3,7 +3,50 @@ module Macron
     module Api
       module V1
         class ArticlesController < BaseController
-          before_action :set_article, only: %i[show update]
+          include Macron::Cms::ApiSerialization
+
+          before_action :set_article, only: %i[show update destroy]
+
+          def index
+            articles = Article.all
+            if params[:q].present?
+              query = "%#{params[:q].to_s.strip.downcase}%"
+              articles = articles.where(
+                "LOWER(title) LIKE :q OR LOWER(slug) LIKE :q OR LOWER(COALESCE(meta_title, '')) LIKE :q OR LOWER(COALESCE(meta_description, '')) LIKE :q",
+                q: query
+              )
+            end
+
+            page = [ params[:page].to_i, 1 ].max
+            per_page = params[:per_page].present? ? [ [ params[:per_page].to_i, 1 ].max, 100 ].min : 20
+            total_count = articles.count
+            total_pages = (total_count.to_f / per_page).ceil
+
+            include_blocks = ActiveModel::Type::Boolean.new.cast(params[:include_blocks])
+
+            scope = articles.includes(:featured_image_blob, background_image_attachment: :blob)
+            scope = scope.includes(article_contents: [ :content, files_attachments: :blob ]) if include_blocks
+
+            records = scope.offset((page - 1) * per_page).limit(per_page)
+
+            serialized = records.map do |art|
+              data = serialize_article(art)
+              if include_blocks
+                data[:content_blocks] = serialize_blocks_collection(art.article_contents.order(:sort_order, :id))
+              end
+              data
+            end
+
+            render json: {
+              articles: serialized,
+              meta: {
+                page: page,
+                per_page: per_page,
+                total_count: total_count,
+                total_pages: total_pages
+              }
+            }
+          end
 
           def show
             render json: serialize_article_with_blocks(@article)
@@ -19,6 +62,7 @@ module Macron
               Article.new
             end
 
+            was_new_record = @article.new_record?
             @article.assign_attributes(article_attributes)
 
             ActiveRecord::Base.transaction do
@@ -27,12 +71,16 @@ module Macron
                 return
               end
 
+              handle_background_image!(@article)
+
               if params.key?(:content_blocks)
                 sync_content_blocks!(@article, params[:content_blocks])
               end
+
+              @article.sync_featured_image!
             end
 
-            status = @article.previously_new_record? ? :created : :ok
+            status = was_new_record ? :created : :ok
             render json: serialize_article_with_blocks(@article), status: status
           rescue ArgumentError => e
             render json: { errors: [ e.message ] }, status: :unprocessable_entity
@@ -47,9 +95,13 @@ module Macron
                 return
               end
 
+              handle_background_image!(@article)
+
               if params.key?(:content_blocks)
                 sync_content_blocks!(@article, params[:content_blocks])
               end
+
+              @article.sync_featured_image!
             end
 
             render json: serialize_article_with_blocks(@article), status: :ok
@@ -59,6 +111,13 @@ module Macron
             render json: { errors: e.record.errors.full_messages }, status: :unprocessable_entity
           end
 
+          def destroy
+            id = @article.id
+            slug = @article.slug
+            @article.destroy!
+            render json: { deleted: true, id: id, slug: slug }, status: :ok
+          end
+
           private
 
           def set_article
@@ -68,11 +127,6 @@ module Macron
           end
 
           def find_existing_article(attrs)
-            if attrs[:name].present?
-              existing = Article.find_by(name: attrs[:name])
-              return existing if existing
-            end
-
             if attrs[:slug].present?
               existing = Article.find_by(slug: attrs[:slug])
               return existing if existing
@@ -90,8 +144,8 @@ module Macron
             raw = params[:article].presence || params
             raw.permit(
               :title,
-              :name,
               :slug,
+              :published_at,
               :meta_title,
               :meta_description,
               :background_color,
@@ -100,84 +154,104 @@ module Macron
             )
           end
 
+          def handle_background_image!(article)
+            raw = params[:article].presence || params
+
+            purge = ActiveModel::Type::Boolean.new.cast(raw[:purge_background_image] || params[:purge_background_image])
+            if purge && article.background_image.attached?
+              article.background_image.purge
+            end
+
+            bg_upload = raw[:background_image_upload] || params[:background_image_upload]
+            if bg_upload.present?
+              InlineAssetAttacher.attach_background(article: article, upload_data: bg_upload, replace: true)
+              return
+            end
+
+            bg_url = raw[:background_image_url] || params[:background_image_url]
+            if bg_url.present?
+              RemoteAssetAttacher.attach_background(article: article, url: bg_url, replace: true)
+            end
+          end
+
           def sync_content_blocks!(article, blocks_params)
             return unless blocks_params.is_a?(Array)
 
-            # Cleanly replace existing content blocks
-            article.article_contents.destroy_all
+            existing_blocks = article.article_contents.index_by(&:id)
+            seen_ids = []
 
             blocks_params.each_with_index do |block_data, index|
               raw_block = block_data.respond_to?(:to_unsafe_h) ? block_data.to_unsafe_h : block_data.to_h
+              block_id = (raw_block["id"] || raw_block[:id]).presence&.to_i
+
               content_type_name = raw_block["content_type"] || raw_block[:content_type]
-              content_type = Content.find_by(name: content_type_name.to_s.strip)
+              content_type = Content.find_by(name: content_type_name.to_s.strip) if content_type_name.present?
 
-              if content_type.nil?
-                raise ArgumentError, "Unknown content type: '#{content_type_name}'. Available types: #{Content.pluck(:name).join(', ')}"
+              raw_payload = raw_block["payload"] || raw_block[:payload] || {}
+              order = (raw_block["sort_order"] || raw_block[:sort_order]).presence || (index + 1)
+
+              article_content = if block_id && existing_blocks.key?(block_id)
+                seen_ids << block_id
+                existing_blocks[block_id]
+              else
+                article.article_contents.build
               end
 
-              raw_payload = raw_block["payload"] || raw_block[:payload] || {}
-              remote_url = raw_block["image_url"] || raw_block[:image_url] ||
-                           raw_block["file_url"] || raw_block[:file_url] ||
-                           raw_block["upload_url"] || raw_block[:upload_url] ||
-                           raw_payload["upload"]
+              if content_type
+                article_content.content = content_type
+              elsif article_content.new_record?
+                raise ArgumentError, "Unknown content type: '#{content_type_name}'. Available types: #{Content.pluck(:name).join(', ')}"
+              end
 
-              order = (raw_block["sort_order"] || raw_block[:sort_order]).presence || (index + 1)
+              article_content.sort_order = order.to_i
 
-              article_content = article.article_contents.build(
-                content: content_type,
-                sort_order: order.to_i
-              )
-              article_content.payload = article_content.filter_payload(raw_payload)
+              filtered = article_content.filter_payload(raw_payload)
+              replace_payload = ActiveModel::Type::Boolean.new.cast(raw_block["replace_payload"] || raw_block[:replace_payload])
+              article_content.payload = if article_content.new_record? || replace_payload
+                filtered
+              else
+                (article_content.payload || {}).merge(filtered)
+              end
 
-              if remote_url.present?
-                article_content.payload["upload"] = remote_url
+              # Check attachment purging
+              purge = ActiveModel::Type::Boolean.new.cast(raw_block["purge_attachment"] || raw_block[:purge_attachment])
+              if purge && article_content.files.attached?
+                article_content.files.purge
               end
 
-              article_content.save!
+              # Check inline base64 upload
+              file_upload = raw_block["file_upload"] || raw_block[:file_upload] || raw_block["upload_data"] || raw_block[:upload_data]
+              if file_upload.present?
+                article_content.save!
+                InlineAssetAttacher.attach(article_content: article_content, upload_data: file_upload, replace: true)
+              else
+                # Check remote URL
+                remote_url = raw_block["image_url"] || raw_block[:image_url] ||
+                             raw_block["file_url"] || raw_block[:file_url] ||
+                             raw_block["upload_url"] || raw_block[:upload_url] ||
+                             raw_payload["upload"]
+
+                if remote_url.present?
+                  article_content.payload ||= {}
+                  article_content.payload["upload"] = remote_url
+                  article_content.save!
 
-              if remote_url.present? && (remote_url.start_with?("http://") || remote_url.start_with?("https://"))
-                RemoteAssetAttacher.attach(article_content: article_content, url: remote_url)
+                  if remote_url.start_with?("http://") || remote_url.start_with?("https://")
+                    RemoteAssetAttacher.attach(article_content: article_content, url: remote_url, replace: true)
+                  end
+                else
+                  article_content.save!
+                end
               end
             end
-          end
 
-          def serialize_article_with_blocks(article)
-            article.reload
-            {
-              article: {
-                id: article.id,
-                title: article.title,
-                name: article.name,
-                slug: article.slug,
-                meta_title: article.meta_title,
-                meta_description: article.meta_description,
-                background_color: article.background_color,
-                text_color: article.text_color,
-                background_options: article.background_options,
-                created_at: article.created_at&.iso8601,
-                updated_at: article.updated_at&.iso8601
-              },
-              content_blocks: article.article_contents.includes(:content).order(:sort_order, :id).map do |ac|
-                block_data = {
-                  id: ac.id,
-                  content_type: ac.content.name,
-                  sort_order: ac.sort_order,
-                  payload: ac.payload
-                }
-
-                if ac.files.attached?
-                  file = ac.files.first
-                  block_data[:attached_file] = {
-                    filename: file.filename.to_s,
-                    content_type: file.content_type,
-                    byte_size: file.byte_size,
-                    url: Rails.application.routes.url_helpers.rails_blob_path(file, only_path: true)
-                  }
-                end
+            # Remove omitted existing blocks
+            blocks_to_destroy = existing_blocks.keys - seen_ids
+            if blocks_to_destroy.any?
+              article.article_contents.where(id: blocks_to_destroy).destroy_all
+            end
 
-                block_data
-              end
-            }
+            normalize_sort_orders!(article)
           end
         end
       end

data/app/controllers/macron/cms/api/v1/content_types_controller.rb

@@ -8,7 +8,9 @@ module Macron
               {
                 id: ct.id,
                 name: ct.name,
-                fields: ct.normalized_fields
+                fields: ct.normalized_fields,
+                convertible_to: ct.normalized_convertible_to,
+                featured_image: ct.featured_image
               }
             end
 

data/app/controllers/macron/cms/article_contents_controller.rb

@@ -2,7 +2,7 @@ module Macron
   module Cms
     class ArticleContentsController < ApplicationController
       before_action :set_article
-      before_action :set_article_content, only: %i[update destroy move]
+      before_action :set_article_content, only: %i[update destroy move convert]
 
       def create
         content = Content.find(params.dig(:article_content, :content_id))
@@ -36,7 +36,7 @@ module Macron
                 newly_added_id: @article_content.id
               )
             end
-            format.html { redirect_to article_path(@article), notice: "Content block was successfully added." }
+            format.html { redirect_to article_path(@article, view: params[:view].presence), notice: "Content block was successfully added." }
           end
         else
           respond_to do |format|
@@ -47,7 +47,7 @@ module Macron
                 locals: { alert: "Failed to add content block: #{@article_content.errors.full_messages.to_sentence}" }
               )
             end
-            format.html { redirect_to article_path(@article), alert: "Failed to add content block: #{@article_content.errors.full_messages.to_sentence}" }
+            format.html { redirect_to article_path(@article, view: params[:view].presence), alert: "Failed to add content block: #{@article_content.errors.full_messages.to_sentence}" }
           end
         end
       end
@@ -71,7 +71,9 @@ module Macron
 
         attach_files_if_present! unless remove_files.include?("upload") || remove_files.include?("file")
 
-        if @article_content.update(payload: filtered)
+        merged_payload = (@article_content.payload || {}).merge(filtered)
+
+        if @article_content.update(payload: merged_payload)
           respond_to do |format|
             format.turbo_stream do
               render_content_blocks_stream(
@@ -79,7 +81,7 @@ module Macron
                 updated_id: @article_content.id
               )
             end
-            format.html { redirect_to article_path(@article), notice: "Content block was successfully updated." }
+            format.html { redirect_to article_path(@article, view: params[:view].presence), notice: "Content block was successfully updated." }
           end
         else
           respond_to do |format|
@@ -90,7 +92,7 @@ module Macron
                 locals: { alert: "Failed to update content block: #{@article_content.errors.full_messages.to_sentence}" }
               )
             end
-            format.html { redirect_to article_path(@article), alert: "Failed to update content block: #{@article_content.errors.full_messages.to_sentence}" }
+            format.html { redirect_to article_path(@article, view: params[:view].presence), alert: "Failed to update content block: #{@article_content.errors.full_messages.to_sentence}" }
           end
         end
       end
@@ -102,7 +104,7 @@ module Macron
           format.turbo_stream do
             render_content_blocks_stream(notice: "Content block was successfully removed.")
           end
-          format.html { redirect_to article_path(@article), notice: "Content block was successfully removed." }
+          format.html { redirect_to article_path(@article, view: params[:view].presence), notice: "Content block was successfully removed." }
         end
       end
 
@@ -128,7 +130,37 @@ module Macron
           format.turbo_stream do
             render_content_blocks_stream(notice: "Content block order updated.")
           end
-          format.html { redirect_to article_path(@article), notice: "Content block order updated." }
+          format.html { redirect_to article_path(@article, view: params[:view].presence), notice: "Content block order updated." }
+        end
+      end
+
+      def convert
+        target_content = Content.find_by(id: params[:target_content_id]) ||
+                         Content.find_by(name: params[:target_content_type].to_s)
+
+        if @article_content.convert_to(target_content)
+          notice_msg = "Content block was converted to #{target_content.name}."
+          respond_to do |format|
+            format.turbo_stream do
+              render_content_blocks_stream(
+                notice: notice_msg,
+                updated_id: @article_content.id
+              )
+            end
+            format.html { redirect_to article_path(@article, view: params[:view].presence), notice: notice_msg }
+          end
+        else
+          alert_msg = "Failed to convert content block: #{@article_content.errors.full_messages.to_sentence}"
+          respond_to do |format|
+            format.turbo_stream do
+              render turbo_stream: turbo_stream.update(
+                "flash-messages",
+                partial: "macron/cms/shared/flash",
+                locals: { alert: alert_msg }
+              )
+            end
+            format.html { redirect_to article_path(@article, view: params[:view].presence), alert: alert_msg }
+          end
         end
       end
 
@@ -146,7 +178,7 @@ module Macron
 
         respond_to do |format|
           format.json { render json: { status: "ok" } }
-          format.html { redirect_to article_path(@article), notice: "Content block order updated." }
+          format.html { redirect_to article_path(@article, view: params[:view].presence), notice: "Content block order updated." }
         end
       end
 
@@ -192,14 +224,16 @@ module Macron
 
       def render_content_blocks_stream(notice: nil, alert: nil, newly_added_id: nil, updated_id: nil)
         @content_types = Content.order(:name)
+        compact = params[:view] == "compact"
         turbo_stream_actions = [
           turbo_stream.update(
             "content-blocks-section",
             partial: "macron/cms/articles/content_blocks_section",
             locals: {
               article: @article,
-              article_contents: @article.article_contents.reload,
+              article_contents: @article.article_contents.for_display.order(:sort_order, :id).load,
               content_types: @content_types,
+              compact: compact,
               newly_added_id: newly_added_id,
               updated_id: updated_id
             }

data/app/controllers/macron/cms/articles_controller.rb

@@ -4,11 +4,11 @@ module Macron
       before_action :set_article, only: %i[show edit update destroy purge_background_image]
 
       def index
-        @articles = Article.order(created_at: :desc)
+        @articles = Article.all
       end
 
       def show
-        @article_contents = @article.article_contents.includes(:content).order(:sort_order, :id)
+        @article_contents = @article.article_contents.for_display.order(:sort_order, :id).load
         @content_types = Content.order(:name)
       end
 
@@ -56,7 +56,8 @@ module Macron
       def article_params
         params.require(:article).permit(
           :title,
-          :name,
+          :slug,
+          :published_at,
           :meta_title,
           :meta_description,
           :background_color,

data/app/controllers/macron/cms/content_types_controller.rb

@@ -5,9 +5,11 @@ module Macron
 
       def index
         @content_types = Content.order(:name)
+        @content_types_by_name = @content_types.index_by(&:name)
       end
 
       def show
+        @convertible_targets_by_name = Content.where(name: @content_type.normalized_convertible_to).index_by(&:name)
       end
 
       private

data/app/controllers/macron/cms/dashboard_controller.rb

@@ -3,7 +3,7 @@ module Macron
     class DashboardController < ApplicationController
       def index
         @articles_count = Article.count
-        @recent_articles = Article.order(created_at: :desc).limit(5)
+        @recent_articles = Article.limit(5)
       end
     end
   end

data/app/helpers/macron/cms/content_helper.rb

@@ -4,7 +4,7 @@ module Macron
       def cms_render_article_contents(article)
         return "".html_safe if article.nil?
 
-        contents = article.article_contents.includes(:content).order(:sort_order, :id)
+        contents = article.article_contents.for_display.order(:sort_order, :id)
         rendered = contents.map { |ac| cms_render_widget(ac) }
         safe_join(rendered)
       end

data/app/helpers/macron/cms/fields_helper.rb

@@ -13,6 +13,20 @@ module Macron
         sanitize(raw_html)
       end
 
+      def cms_strip_markdown(text)
+        return "" if text.blank?
+
+        raw_html = Kramdown::Document.new(text.to_s, input: "GFM").to_html
+        strip_tags(raw_html).to_s.squish
+      end
+
+      def cms_top_field_definition(article_content)
+        content = article_content.content
+        return nil unless content
+
+        content.normalized_fields.first
+      end
+
       def cms_render_field(field_def, value: nil, input_name: nil, input_id: nil)
         field_hash = field_def.stringify_keys
         fname = field_hash["name"]

data/app/models/macron/cms/article.rb

@@ -11,18 +11,52 @@ module Macron
       DEFAULT_BACKGROUND_POSITION = "center"
       DEFAULT_BACKGROUND_ATTACHMENT = "scroll"
 
-      before_validation :derive_name_from_title
+      default_scope { order(published_at: :desc, created_at: :desc) }
+
+      before_validation :normalize_slug
+      before_validation :set_default_published_at, on: :create
+      before_save :ensure_published_at
 
       extend FriendlyId
-      friendly_id :name, use: :slugged
+      friendly_id :slug_candidate, use: %i[slugged history]
 
       validates :title, presence: true
-      validates :name, presence: true, uniqueness: true
+      validates :slug, presence: true, uniqueness: true
+
+      def should_generate_new_friendly_id?
+        slug_changed? || super
+      end
+
+      def slug_candidate
+        slug.presence || title
+      end
 
       has_many :article_contents, -> { order(:sort_order) }, class_name: "Macron::Cms::ArticleContent", dependent: :destroy
       has_many :contents, through: :article_contents
 
       has_one_attached :background_image
+      belongs_to :featured_image_blob, class_name: "ActiveStorage::Blob", optional: true
+
+      def featured_image
+        featured_image_blob
+      end
+
+      def sync_featured_image!
+        return if destroyed? || marked_for_destruction?
+
+        next_blob_id = article_contents
+          .unscoped
+          .where(article_id: id)
+          .joins(:content, :files_attachments)
+          .where(macron_cms_contents: { featured_image: true })
+          .order(:sort_order, :id, Arel.sql("active_storage_attachments.id ASC"))
+          .pick(Arel.sql("active_storage_attachments.blob_id"))
+
+        if featured_image_blob_id != next_blob_id
+          update_column(:featured_image_blob_id, next_blob_id)
+          self.featured_image_blob_id = next_blob_id
+        end
+      end
 
       def seo_title
         meta_title.presence || title
@@ -58,20 +92,16 @@ module Macron
 
       private
 
-      def derive_name_from_title
-        return if name.present? || title.blank?
-
-        base = title.parameterize.presence || "article"
-        candidate = base
-        scope = id.present? ? self.class.where.not(id: id) : self.class.all
+      def set_default_published_at
+        self.published_at = Time.current if published_at.blank?
+      end
 
-        counter = 1
-        while scope.exists?(name: candidate)
-          counter += 1
-          candidate = "#{base}-#{counter}"
-        end
+      def ensure_published_at
+        self.published_at ||= (created_at.presence || Time.current)
+      end
 
-        self.name = candidate
+      def normalize_slug
+        self.slug = slug.to_s.parameterize.presence
       end
     end
   end

data/app/models/macron/cms/article_content.rb

@@ -6,12 +6,17 @@ module Macron
 
       has_many_attached :files
 
+      after_save :sync_article_featured_image
+      after_destroy :sync_article_featured_image, unless: -> { destroyed_by_association.present? }
+
       before_validation :assign_default_sort_order, on: :create
 
       validates :sort_order, numericality: { only_integer: true }
 
       default_scope -> { order(:sort_order, :id) }
 
+      scope :for_display, -> { with_attached_files.includes(:content) }
+
       def upload
         files.first
       end
@@ -49,6 +54,21 @@ module Macron
         end
       end
 
+      def convert_to(target_content)
+        unless target_content.is_a?(Content) && content&.convertible_to?(target_content)
+          errors.add(:base, "Cannot convert #{content&.name || 'unknown'} block to #{target_content&.name || 'unknown'}")
+          return false
+        end
+
+        updated_payload = (payload || {}).deep_dup
+        if files.attached? && updated_payload["upload"].blank? &&
+           target_content.normalized_fields.any? { |f| f["name"] == "upload" && f["kind"] == "file" }
+          updated_payload["upload"] = upload.filename.to_s
+        end
+
+        update(content: target_content, payload: updated_payload)
+      end
+
       private
 
       def assign_default_sort_order
@@ -58,6 +78,10 @@ module Macron
         max_order = article.article_contents.unscoped.where(article_id: article.id).maximum(:sort_order)
         self.sort_order = max_order ? max_order + 1 : 1
       end
+
+      def sync_article_featured_image
+        article&.sync_featured_image!
+      end
     end
   end
 end