maglevcms 2.0.0 → 3.0.0.beta1

data/app/models/maglev/section.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Definition of a section in the theme
+# Don't misunstand it with the content of a section within a page or a site
 module Maglev
   class Section
     include ActiveModel::Model
@@ -23,6 +25,14 @@ module Maglev
 
     ## methods ##
 
+    def human_name
+      ::I18n.t("#{i18n_scope}.name", default: name.humanize)
+    end
+
+    def human_blocks_label(default = nil)
+      ::I18n.t("#{i18n_scope}.blocks.label", default: blocks_label || default)
+    end
+
     def site_scoped?
       !!site_scoped
     end
@@ -31,19 +41,43 @@ module Maglev
       !!singleton
     end
 
+    def root_blocks
+      blocks.select(&:root?)
+    end
+
+    def blocks_tree?
+      blocks_presentation == 'tree'
+    end
+
+    def accepts_blocks?
+      blocks.any? { |block| block.accept.present? }
+    end
+
     def viewport_fixed_position?
-      !!viewport_fixed_position?
+      !!viewport_fixed_position
+    end
+
+    def main_settings
+      settings.reject(&:advanced?)
+    end
+
+    def advanced_settings
+      settings.select(&:advanced?)
     end
 
     def assign_attributes_from_yaml(hash)
       attributes = prepare_default_attributes(hash).merge(
         settings: ::Maglev::Section::Setting.build_many(hash['settings']),
-        blocks: ::Maglev::Section::Block.build_many(hash['blocks'])
+        blocks: ::Maglev::Section::Block::Store.new(hash['blocks'], section: self)
       )
 
       assign_attributes(attributes)
     end
 
+    def i18n_scope
+      "maglev.themes.#{theme.id}.sections.#{id}"
+    end
+
     ## class methods ##
 
     def self.build(hash)
@@ -78,14 +112,28 @@ module Maglev
         @array = array
       end
 
-      def find(id)
-        @array.find { |section| section.id == id }
+      def find(type)
+        @array.find { |section| section.id == type }
+      end
+
+      def find_all_by_type(type)
+        @array.select { |section| section.id == type }
       end
 
       def grouped_by_category
         @array.group_by(&:category)
       end
 
+      def available_for(sections_content)
+        # we don't want to add site_scoped sections or singleton sections that are already present on the page
+        new_array = @array.reject do |section|
+          (section.site_scoped? || section.singleton?) && sections_content.any? do |section_content|
+            section_content.type == section.id
+          end
+        end
+        self.class.new(new_array)
+      end
+
       def as_json(**_options)
         @array.as_json
       end

data/app/models/maglev/sections_content_store.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: maglev_sections_content_stores
+#
+#  id                    :bigint           not null, primary key
+#  container_type        :string
+#  published             :boolean          default(FALSE)
+#  sections_translations :jsonb
+#  created_at            :datetime         not null
+#  updated_at            :datetime         not null
+#  container_id          :string
+#
+# Indexes
+#
+#  index_maglev_sections_content_stores_on_published       (published)
+#  maglev_sections_content_stores_container                (container_id,container_type)
+#  maglev_sections_content_stores_container_and_published  (container_id,container_type,published)
+#
+module Maglev
+  class SectionsContentStore < ApplicationRecord
+    ## concerns ##
+    include Maglev::Translatable
+    include Maglev::SectionsConcern
+
+    ## associations ##
+    belongs_to :container, polymorphic: true
+
+    ## scopes ##
+    scope :published, -> { where(published: true) }
+
+    ## translations ##
+    translates :sections
+  end
+end

data/app/models/maglev/setting_types/base.rb

@@ -5,6 +5,14 @@ class Maglev::SettingTypes::Base
   def cast_value(value)
     value
   end
+
+  def content_label(_value)
+    nil
+  end
+
+  def content_image(_value)
+    nil
+  end
 end
 
 # rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/setting_types/collection_item.rb

@@ -6,8 +6,12 @@ class Maglev::SettingTypes::CollectionItem < Maglev::SettingTypes::Base
     if value.is_a?(String)
       { id: value }
     else
-      value
+      value&.symbolize_keys
     end
   end
+
+  def content_label(value)
+    value&.with_indifferent_access&.fetch(:label, nil)
+  end
 end
 # rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/setting_types/image.rb

@@ -9,5 +9,9 @@ class Maglev::SettingTypes::Image < Maglev::SettingTypes::Base
       value || {}
     end
   end
+
+  def content_image(value)
+    value&.fetch('url', nil)
+  end
 end
 # rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/setting_types/link.rb

@@ -9,5 +9,9 @@ class Maglev::SettingTypes::Link < Maglev::SettingTypes::Base
       { text: 'Link', link_type: 'url', href: '#' }.merge(value.symbolize_keys)
     end
   end
+
+  def content_label(value)
+    value&.fetch('text', nil)
+  end
 end
 # rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/setting_types/text.rb

@@ -2,5 +2,10 @@
 
 # rubocop:disable Style/ClassAndModuleChildren
 class Maglev::SettingTypes::Text < Maglev::SettingTypes::Base
+  def content_label(value)
+    return nil if value.blank?
+
+    Nokogiri::HTML(value.gsub(%r{<br/?>}, ' ')).text.strip
+  end
 end
 # rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/site/locales_concern.rb

@@ -5,12 +5,8 @@ module Maglev::Site::LocalesConcern
   extend ActiveSupport::Concern
 
   included do
-    ## serializers ##
-    if Rails::VERSION::MAJOR >= 8 || (Rails::VERSION::MAJOR >= 7 && Rails::VERSION::MINOR.positive?)
-      serialize :locales, coder: LocalesSerializer
-    else
-      serialize :locales, LocalesSerializer
-    end
+    ## custom column type ##
+    attribute :locales, :maglev_locales
 
     ## validation ##
     validates :locales, 'maglev/collection': true, length: { minimum: 1 }
@@ -43,14 +39,8 @@ module Maglev::Site::LocalesConcern
     end
   end
 
-  class LocalesSerializer
-    def self.dump(array)
-      (array || []).map(&:as_json)
-    end
-
-    def self.load(array)
-      (array || []).map { |attributes| Maglev::Site::Locale.new(**attributes.symbolize_keys) }
-    end
+  def many_locales?
+    locales.size > 1
   end
 end
 # rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/site/style_value.rb

@@ -11,18 +11,29 @@ class Maglev::Site::StyleValue
     @value = value
   end
 
-  class Store
-    extend Forwardable
-    def_delegators :@array, :all, :first, :last, :count, :each, :each_with_index, :map, :group_by
+  class AssociationProxy
+    include Enumerable
 
-    attr_reader :array
+    attr_reader :style_values
 
-    def initialize(array)
-      @array = array
+    def initialize(values)
+      @style_values = values
+    end
+
+    def [](id)
+      style_values.find { |setting| setting.id == id }
+    end
+
+    def each(&block)
+      style_values.each(&block)
+    end
+
+    def value_of(id)
+      self[id]&.value
     end
 
     def method_missing(method_name, *_args)
-      setting = array.find { |local_setting| local_setting.id == method_name.to_s }
+      setting = self[method_name.to_s]
       if setting
         setting.value
       else
@@ -31,12 +42,7 @@ class Maglev::Site::StyleValue
     end
 
     def respond_to_missing?(method_name, include_private = false)
-      Rails.logger.debug 'yeasss!!!'
-      array.map(&:id).include?(method_name.to_s) || super
-    end
-
-    def as_json(**_options)
-      @array.as_json
+      style_values.map(&:id).include?(method_name.to_s) || super
     end
   end
 end

data/app/models/maglev/site.rb

@@ -20,6 +20,13 @@ module Maglev
     include Maglev::SectionsConcern
     include Maglev::Translatable
 
+    ## associations ##
+    has_many :sections_content_stores, as: :container, dependent: :destroy
+
+    ## force JSON columns for MariaDB ##
+    attribute :style, :json
+    attribute :sections_translations, :json
+
     ## translations ##
     translates :sections
 
@@ -27,6 +34,7 @@ module Maglev
     validates :name, presence: true
 
     ## methods ##
+
     def api_attributes
       %i[id name]
     end

data/app/models/maglev/theme/section_category.rb

@@ -6,7 +6,12 @@ class Maglev::Theme::SectionCategory
   include ActiveModel::Model
 
   ## attributes ##
-  attr_accessor :name, :id
+  attr_accessor :name, :id, :theme
+
+  ## methods ##
+  def human_name
+    I18n.t("maglev.themes.#{theme.id}.categories.#{id}.name", default: name.humanize)
+  end
 
   ## class methods ##
 

data/app/models/maglev/theme/style_setting.rb

@@ -33,7 +33,7 @@ class Maglev::Theme::StyleSetting
     attributes = hash.slice('id', 'label', 'type', 'default')
     options = hash.except('id', 'label', 'type', 'default')
 
-    new(attributes.merge(options: options))
+    new(attributes.merge(options: options.with_indifferent_access))
   end
 
   def self.build_many(list)

data/app/models/maglev/theme.rb

@@ -13,6 +13,11 @@ module Maglev
 
     ## methods ##
 
+    def initialize(...)
+      super
+      attach_theme_to_associations
+    end
+
     def find_setting!(section_id, block_id, setting_id)
       setting = find_setting(section_id, block_id, setting_id)
       raise Maglev::Errors::UnknownSetting.new(section_id, block_id, setting_id) if setting.nil?
@@ -25,6 +30,10 @@ module Maglev
       section_setting_types[key]
     end
 
+    def style?
+      style_settings.present?
+    end
+
     private
 
     def section_setting_types
@@ -47,5 +56,9 @@ module Maglev
         hash["#{parent_key}.#{setting.id}"] = setting
       end
     end
+
+    def attach_theme_to_associations
+      section_categories&.each { |category| category.theme = self }
+    end
   end
 end

data/app/services/concerns/maglev/content/helpers_concern.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    module HelpersConcern
+      private
+
+      def theme
+        @theme ||= fetch_theme.call
+      end
+
+      def site
+        @site ||= fetch_site.call
+      end
+
+      def site_scoped?
+        section_definition.site_scoped?
+      end
+
+      def section_definition
+        # by default, use the page to find the section definition since every site scoped section is also in the page
+        @section_definition ||= theme.sections.find(
+          find_section&.fetch('type', nil)
+        )
+      end
+
+      def block_definition
+        @block_definition ||= site_scoped? ? find_block_definition(site) : find_block_definition(page)
+      end
+
+      def find_section(source = page)
+        source.find_section_by_id(section_id)
+      end
+
+      def find_section_definition(source, section_id)
+        theme.sections.find(find_section(source, section_id)&.fetch('type', nil))
+      end
+
+      def find_section_content(source)
+        find_section(source)['settings']
+      end
+
+      def find_blocks(source)
+        find_section(source)&.fetch('blocks', nil)
+      end
+
+      def find_block(source)
+        find_blocks(source).find { |block| block['id'] == block_id }
+      end
+
+      def find_block_content(source)
+        find_block(source)['settings']
+      end
+
+      def find_block_definition(source = page)
+        section_definition.blocks.find(find_block(source)&.fetch('type', nil))
+      end
+
+      def update_setting_value(setting, current_content)
+        setting_content = current_content.find { |s| s['id'] == setting.id }
+        value = content[setting.id.to_sym]
+
+        if setting_content.nil?
+          current_content.push({ id: setting.id, value: value })
+        else
+          setting_content['value'] = value
+        end
+      end
+
+      def check_section_lock_version!(source)
+        check_lock_version!(source, find_section(source), 'update_section')
+      end
+
+      def check_block_lock_version!(source)
+        check_lock_version!(source, find_block(source), 'update_block')
+      end
+
+      def check_lock_version!(source, section_or_block, action_name)
+        return if lock_version.blank? # without a lock version, we disable the lock version check
+
+        current_lock_version = section_or_block['lock_version'].to_i
+
+        # always increment the lock version
+        section_or_block['lock_version'] = lock_version.to_i + 1
+
+        # if the lock version is the same, we don't need to raise an error
+        return if current_lock_version == lock_version.to_i
+
+        raise ActiveRecord::StaleObjectError.new(source, action_name)
+      end
+
+      def reset_memoization
+        @theme = nil
+        @site = nil
+        @section_definition = nil
+        @block_definition = nil
+      end
+    end
+  end
+end

data/app/services/concerns/maglev/get_page_sections/transform_section_concern.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+module Maglev::GetPageSections::TransformSectionConcern
+  extend ActiveSupport::Concern
+
+  included do
+    include Maglev::GetPageSections::TransformTextConcern
+    include Maglev::GetPageSections::TransformLinkConcern
+    include Maglev::GetPageSections::TransformCollectionItemConcern
+  end
+
+  protected
+
+  def transform_section(section)
+    definition = theme.sections.find(section['type'])
+
+    raise_unknown_section_error(section['type']) unless definition
+
+    transform_if_site_scoped(section, definition)
+    transform_section_blocks(section['blocks'], definition)
+    transform_section_settings(section, definition)
+
+    section
+  end
+
+  # rubocop:disable Style/StringHashKeys
+  def transform_if_site_scoped(section, definition)
+    return unless definition.site_scoped?
+
+    site_section = find_site_section(section['type'])
+
+    return unless site_section
+
+    # keep the same section id all over the pages
+    section.merge!(
+      'id' => site_section['id'],
+      'settings' => site_section['settings'],
+      'blocks' => site_section['blocks'],
+      'lock_version' => site_section['lock_version']
+    )
+  end
+  # rubocop:enable Style/StringHashKeys
+
+  def transform_section_blocks(blocks, definition)
+    blocks.each do |block|
+      block_definition = definition.blocks.find(block['type'])
+
+      next unless block_definition
+
+      transform_section_settings(block, block_definition)
+    end
+  end
+
+  def transform_section_settings(section, definition)
+    remove_unused_settings(section, definition)
+
+    definition.settings.each do |setting|
+      section_setting = find_section_setting(section, setting.id)
+
+      next unless section_setting
+
+      transform_content_setting(section_setting, setting)
+    end
+  end
+
+  def transform_content_setting(content, setting)
+    case setting.type
+    when 'link'
+      transform_link_content_setting(content, setting)
+    when 'text'
+      transform_text_content_setting(content, setting)
+    when 'collection_item'
+      transform_collection_item_content_setting(content, setting)
+    end
+  end
+
+  def remove_unused_settings(section, definition)
+    section['settings'].select! do |setting|
+      definition.settings.any? do |definition_setting|
+        definition_setting.id == setting['id']
+      end
+    end
+  end
+
+  def find_section_setting(section, setting_id)
+    # NOTE: works for both sections and blocks
+    section['settings'].find { |setting| setting['id'] == setting_id }
+  end
+
+  def raise_unknown_section_error(type)
+    raise ::Maglev::Errors::UnknownSection, "Unknown Maglev section type (#{type})" unless Rails.env.production?
+
+    Rails.logger.warn "[#{theme.id}] unknown Maglev section type (#{type})"
+  end
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/app/services/maglev/app_container.rb

@@ -14,7 +14,7 @@ module Maglev
     dependency :fetch_site,                 class: Maglev::FetchSite, depends_on: %i[config context]
     dependency :fetch_theme,                class: Maglev::FetchTheme, depends_on: %i[fetch_site context]
     dependency :fetch_theme_layout,         class: Maglev::FetchThemeLayout, depends_on: %i[fetch_theme]
-    dependency :fetch_style,                class: Maglev::FetchStyle
+    dependency :fetch_style,                class: Maglev::FetchStyle, depends_on: %i[fetch_site fetch_theme]
     dependency :fetch_sections_path,        class: Maglev::FetchSectionsPath, depends_on: :fetch_theme
     dependency :fetch_section_screenshot_path, class: Maglev::FetchSectionScreenshotPath,
                                                depends_on: :fetch_sections_path
@@ -40,9 +40,34 @@ module Maglev
                                             depends_on: %i[fetch_site fetch_theme
                                                            fetch_static_pages
                                                            fetch_collection_items get_page_fullpath]
+    dependency :get_published_page_sections, class: Maglev::GetPublishedPageSectionsService,
+                                             depends_on: %i[fetch_site fetch_theme
+                                                            fetch_static_pages
+                                                            fetch_collection_items get_page_fullpath]
     dependency :get_page_section_names,     class: Maglev::GetPageSectionNames, depends_on: :fetch_theme
+
+    dependency :create_page,                class: Maglev::CreatePageService, depends_on: :fetch_site
     dependency :clone_page,                 class: Maglev::ClonePage, depends_on: :fetch_site
-    dependency :persist_page,               class: Maglev::PersistPage, depends_on: %i[fetch_theme]
+
+    dependency :persist_style,              class: Maglev::PersistStyleService, depends_on: %i[fetch_site fetch_theme]
+
+    dependency :add_section,                class: Maglev::Content::AddSectionService,
+                                            depends_on: %i[fetch_site fetch_theme]
+    dependency :update_section,             class: Maglev::Content::UpdateSectionService,
+                                            depends_on: %i[fetch_site fetch_theme]
+    dependency :delete_section,             class: Maglev::Content::DeleteSectionService,
+                                            depends_on: %i[fetch_site fetch_theme]
+
+    dependency :add_section_block,          class: Maglev::Content::AddSectionBlockService,
+                                            depends_on: %i[fetch_site fetch_theme]
+    dependency :update_section_block,       class: Maglev::Content::UpdateSectionBlockService,
+                                            depends_on: %i[fetch_site fetch_theme]
+    dependency :delete_section_block,       class: Maglev::Content::DeleteSectionBlockService,
+                                            depends_on: %i[fetch_site fetch_theme]
+    dependency :sort_section_blocks,        class: Maglev::Content::SortSectionBlocksService,
+                                            depends_on: %i[fetch_site fetch_theme]
+
+    dependency :publish,                    class: Maglev::PublishService
 
     def call
       self

data/app/services/maglev/content/add_section_block_service.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    class AddSectionBlockService
+      include Injectable
+      include Maglev::Content::HelpersConcern
+
+      dependency :fetch_theme
+      dependency :fetch_site
+
+      argument :page
+      argument :section_id
+      argument :block_type
+      argument :parent_id, default: nil
+      argument :lock_version, default: nil
+
+      def call
+        raise Maglev::Errors::UnknownSection unless section_definition
+
+        block_content = build_block_content
+
+        ActiveRecord::Base.transaction do
+          if section_definition.site_scoped?
+            add_to_section!(site, block_content)
+          else
+            add_to_section!(page, block_content)
+          end
+        end
+
+        block_content
+      end
+
+      private
+
+      def build_block_content
+        section_definition.build_block_content_for(block_type).tap do |block_content|
+          block_content[:parent_id] = parent_id if parent_id.present?
+        end
+      end
+
+      def add_to_section!(source, block_content)
+        check_section_lock_version!(source)
+
+        source.sections_translations_will_change!
+        section = source.find_section_by_id(section_id)
+        section['blocks'] ||= []
+        section['blocks'].push(block_content)
+        source.save!
+      end
+    end
+  end
+end