maglevcms 2.1.0 → 3.0.0.beta2

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

@@ -38,5 +38,9 @@ module Maglev::Site::LocalesConcern
       end
     end
   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,9 @@ 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
@@ -31,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

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    class AddSectionService
+      include Injectable
+      include Maglev::Content::HelpersConcern
+
+      dependency :fetch_theme
+      dependency :fetch_site
+
+      argument :page
+      argument :section_type
+      argument :content, default: nil
+      argument :position, default: -1
+      argument :dry_run, default: false
+      argument :site, default: nil
+      argument :theme, default: nil
+
+      def call
+        raise Maglev::Errors::UnknownSection unless section_definition
+
+        section_content = build_section_content
+
+        ActiveRecord::Base.transaction do
+          add_to_site!(section_content) if can_add_to_site?
+          add_to_page!(section_content) if can_add_to_page?
+        end
+
+        # in case the instance of the service is reused, we need to reset the memoization
+        # this is the case for the setup_pages service
+        reset_memoization
+
+        section_content
+      end
+
+      private
+
+      def theme
+        @theme ||= fetch_theme.call
+      end
+
+      def site
+        @site ||= fetch_site.call
+      end
+
+      def add_to_site!(section_content)
+        # we don't care about the position for site scoped sections
+        site.sections_translations_will_change!
+
+        site.sections ||= []
+        site.sections.push(section_content)
+        site.prepare_sections(theme)
+
+        site.save! unless dry_run
+      end
+
+      def add_to_page!(section_content)
+        page.sections_translations_will_change!
+        page.sections ||= []
+        page.sections.insert(final_position, section_content)
+        page.prepare_sections(theme)
+
+        page.save! unless dry_run
+      end
+
+      def can_add_to_site?
+        # We don't want to add the section to the site if there is already a section with the same type
+        site_scoped? && site.find_sections_by_type(section_type).empty?
+      end
+
+      def can_add_to_page?
+        # we don't want to add the section if it's a singleton and there is already a section with the same type
+        !(section_definition.singleton? && page.find_sections_by_type(section_type).any?)
+      end
+
+      def build_section_content
+        if site_scoped? && site.find_sections_by_type(section_type).any?
+          site.find_sections_by_type(section_type).first.dup
+        else
+          content || section_definition.build_default_content
+        end.with_indifferent_access
+      end
+
+      def section_definition
+        @section_definition ||= theme.sections.find(section_type)
+      end
+
+      def final_position
+        case section_definition.insert_at
+        when 'top' then 0
+        when 'bottom' then page.sections.count
+        else
+          position
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    class DeleteSectionBlockService
+      include Injectable
+      include Maglev::Content::HelpersConcern
+
+      dependency :fetch_theme
+      dependency :fetch_site
+
+      argument :page
+      argument :section_id
+      argument :block_id
+      argument :lock_version, default: nil
+
+      def call
+        raise Maglev::Errors::UnknownSection unless section_definition
+        raise Maglev::Errors::UnknownBlock unless block_definition
+
+        ActiveRecord::Base.transaction do
+          if site_scoped?
+            delete_section_block!(site)
+          else
+            delete_section_block!(page)
+          end
+        end
+      end
+
+      private
+
+      def delete_section_block!(source)
+        check_section_lock_version!(source)
+
+        source.sections_translations_will_change!
+        delete_section_block(source)
+        source.save!
+      end
+
+      def delete_section_block(source)
+        find_blocks(source).delete_if { |block| block['id'] == block_id }
+      end
+    end
+  end
+end