maglevcms 2.1.0 → 3.0.0.beta1

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    class DeleteSectionService
+      include Injectable
+      include Maglev::Content::HelpersConcern
+
+      dependency :fetch_theme
+      dependency :fetch_site
+
+      argument :page
+      argument :section_id
+
+      def call
+        raise Maglev::Errors::UnknownSection unless section_definition
+
+        ActiveRecord::Base.transaction do
+          # we never delete site scoped sections:
+          # A page might not need it anymore but others might still need it.
+          delete_section!(page)
+        end
+      end
+
+      private
+
+      def delete_section!(source)
+        source.sections_translations_will_change!
+        source.delete_section(section_id)
+        source.save!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    class SortSectionBlocksService
+      include Injectable
+      include Maglev::Content::HelpersConcern
+
+      dependency :fetch_theme
+      dependency :fetch_site
+
+      argument :page
+      argument :section_id
+      argument :block_ids
+      argument :parent_id, default: nil
+      argument :lock_version, default: nil
+
+      def call
+        raise Maglev::Errors::UnknownSection unless section_definition
+
+        ActiveRecord::Base.transaction do
+          if site_scoped?
+            sort_section_blocks!(site)
+          else
+            sort_section_blocks!(page)
+          end
+        end
+      end
+
+      private
+
+      def sort_section_blocks!(source)
+        check_section_lock_version!(source)
+
+        source.sections_translations_will_change!
+        sort_section_blocks(source)
+        source.save!
+      end
+
+      def sort_section_blocks(source)
+        find_blocks(source)&.sort_by! do |block|
+          block['parent_id'] == parent_id ? block_ids.index(block['id']) || Float::INFINITY : -1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    class UpdateSectionBlockService
+      include Injectable
+      include Maglev::Content::HelpersConcern
+
+      dependency :fetch_theme
+      dependency :fetch_site
+
+      argument :page
+      argument :section_id
+      argument :block_id
+      argument :content
+      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?
+            update_section_block_content!(site)
+          else
+            update_section_block_content!(page)
+          end
+        end
+      end
+
+      private
+
+      def update_section_block_content!(source)
+        check_block_lock_version!(source)
+
+        source.sections_translations_will_change!
+        update_section_block_content(source)
+        source.save!
+      end
+
+      def update_section_block_content(source)
+        current_section_block_content = find_block_content(source)
+
+        block_definition.settings.each do |setting|
+          next unless content.key?(setting.id.to_sym)
+
+          update_setting_value(setting, current_section_block_content)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    class UpdateSectionService
+      include Injectable
+      include Maglev::Content::HelpersConcern
+
+      dependency :fetch_theme
+      dependency :fetch_site
+
+      argument :page
+      argument :section_id
+      argument :content
+      argument :lock_version, default: nil
+
+      def call
+        raise Maglev::Errors::UnknownSection unless section_definition
+
+        ActiveRecord::Base.transaction do
+          if site_scoped?
+            update_section_content!(site)
+          else
+            update_section_content!(page)
+          end
+        end
+      end
+
+      private
+
+      def update_section_content!(source)
+        check_section_lock_version!(source)
+
+        source.sections_translations_will_change!
+        update_section_content(source)
+        source.save!
+      end
+
+      def update_section_content(source)
+        current_section_content = find_section_content(source)
+
+        section_definition.settings.each do |setting|
+          next unless content.key?(setting.id.to_sym)
+
+          update_setting_value(setting, current_section_content)
+        end
+      end
+    end
+  end
+end

data/app/services/maglev/create_page_service.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Maglev
+  class CreatePageService
+    include Injectable
+
+    dependency :fetch_site
+
+    argument :attributes
+    argument :site, default: nil
+
+    def call
+      page = translate(build_page)
+      page.save
+      page
+    end
+
+    private
+
+    def site
+      @site ||= fetch_site.call
+    end
+
+    def build_page
+      Maglev::Page.new(attributes)
+    end
+
+    def translate(page)
+      site.locale_prefixes.each do |locale|
+        Maglev::I18n.with_locale(locale) do
+          # the title mightn't be empty if we set the title_translations field in "attributes"
+          page.title ||= attributes[:title]
+          page.path ||= attributes[:path]
+        end
+      end
+      page
+    end
+  end
+end

data/app/services/maglev/fetch_style.rb

@@ -5,34 +5,44 @@ module Maglev
   class FetchStyle
     include Injectable
 
-    argument :site
-    argument :theme
+    dependency :fetch_site
+    dependency :fetch_theme
 
     def call
-      Maglev::Site::StyleValue::Store.new(
+      Maglev::Site::StyleValue::AssociationProxy.new(
         build_style_value_list
       )
     end
 
     protected
 
+    def site
+      @site ||= fetch_site.call
+    end
+
+    def theme
+      @theme ||= fetch_theme.call
+    end
+
     def build_style_value_list
-      theme.style_settings.map do |setting|
-        build_style_value(setting)
+      theme.style_settings.map do |definition|
+        build_style_value(definition)
       end
     end
 
-    def build_style_value(setting)
+    def build_style_value(definition)
       Maglev::Site::StyleValue.new(
-        setting.id,
-        setting.type,
-        custom_value(setting)
+        definition.id,
+        definition.type,
+        custom_value(definition)
       )
     end
 
-    def custom_value(setting)
-      value = (site.style || []).find { |local_value| local_value['id'] == setting.id }
-      value && value['type'] == setting.type ? value['value'] : setting.default
+    def custom_value(definition)
+      value = (site.style || []).find do |local_value|
+        local_value['id'] == definition.id && local_value['type'] == definition.type
+      end
+      value ? value['value'] : definition.default
     end
   end
 end

data/app/services/maglev/get_base_url.rb

@@ -26,7 +26,9 @@ module Maglev
     end
 
     def live_url
-      nil
+      return nil if context.controller.request.nil?
+
+      context.controller.request.base_url
     end
   end
 end

data/app/services/maglev/get_page_section_names.rb

@@ -12,7 +12,7 @@ module Maglev
     def call
       (page.sections || []).map do |section|
         definition = theme.sections.find(section['type'])
-        { id: section['id'], name: definition.name }
+        { id: section['id'], name: definition.human_name }
       end
     end
 

data/app/services/maglev/get_page_sections.rb

@@ -6,9 +6,7 @@ module Maglev
   # Also replace the links by their real values based on the context (live editing or not).
   class GetPageSections
     include Injectable
-    include Maglev::GetPageSections::TransformTextConcern
-    include Maglev::GetPageSections::TransformLinkConcern
-    include Maglev::GetPageSections::TransformCollectionItemConcern
+    include Maglev::GetPageSections::TransformSectionConcern
 
     dependency :fetch_site
     dependency :fetch_theme
@@ -17,11 +15,11 @@ module Maglev
     dependency :get_page_fullpath
 
     argument :page
-    argument :page_sections, default: nil
+    argument :section_id, default: nil
     argument :locale, default: nil
 
     def call
-      (page_sections || page.sections || []).map do |section|
+      sections.map do |section|
         transform_section(section.dup)
       end.compact
     end
@@ -36,85 +34,16 @@ module Maglev
       fetch_site.call
     end
 
-    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 = site.find_section(section['type'])
-
-      return unless !page_sections && 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']
-      )
-    end
-    # rubocop:enable Style/StringHashKeys
-
-    def transform_section_blocks(blocks, definition)
-      blocks.each do |block|
-        block_definition = definition.blocks.find { |bd| bd.type == 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 }
+    def sections
+      if section_id.present? # when refreshing the preview of a section in the editor
+        [page.find_section_by_id(section_id)]
+      else
+        page.sections || []
+      end.compact
     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})"
+    def find_site_section(type)
+      site.find_section(type)
     end
   end
 end

data/app/services/maglev/get_published_page_sections_service.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Maglev
+  class GetPublishedPageSectionsService
+    include Injectable
+    include Maglev::GetPageSections::TransformSectionConcern
+
+    dependency :fetch_site
+    dependency :fetch_theme
+    dependency :fetch_collection_items
+    dependency :fetch_static_pages
+    dependency :get_page_fullpath
+
+    argument :page
+    argument :locale, default: nil
+
+    def call
+      fetch_container_store(page).sections.map do |section|
+        transform_section(section.dup)
+      end.compact
+    end
+
+    protected
+
+    def theme
+      fetch_theme.call
+    end
+
+    def site
+      fetch_site.call
+    end
+
+    def site_store
+      @site_store ||= fetch_container_store(site)
+    end
+
+    def find_site_section(type)
+      site_store.find_sections_by_type(type).first
+    end
+
+    def fetch_container_store(container)
+      store = container.sections_content_stores.published.first
+      raise Maglev::Errors::UnpublishedPage if store.blank?
+
+      store
+    end
+  end
+end

data/app/services/maglev/persist_section_screenshot.rb

@@ -34,7 +34,7 @@ module Maglev
       tmp_file.write(image_data)
       tmp_file.close
 
-      # PNG -> JPG to lower the size of the image
+      # PNG -> JPG to decrease the size of the image
       ::ActiveStorage::Variation.new(format: 'jpg', saver: { quality: 90 }).transform(tmp_file) do |output|
         FileUtils.mkdir_p(screenshots_dir)
         File.open(screenshot_filepath, 'wb') do |f|

data/app/services/maglev/persist_style_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Maglev
+  class PersistStyleService
+    include Injectable
+
+    dependency :fetch_theme
+    dependency :fetch_site
+
+    argument :new_style
+    argument :lock_version, default: nil
+
+    def call
+      site.lock_version = lock_version if lock_version.present?
+      site.style = compute_new_style
+      site.save!
+    end
+
+    private
+
+    def site
+      @site ||= fetch_site.call
+    end
+
+    def theme
+      @theme ||= fetch_theme.call
+    end
+
+    def compute_new_style
+      theme.style_settings.map do |definition|
+        value = new_style[definition.id.to_s]
+        { id: definition.id, value: value, type: definition.type }
+      end
+    end
+  end
+end

data/app/services/maglev/publish_service.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Maglev
+  class PublishService
+    include Injectable
+
+    argument :site
+    argument :page
+
+    def call
+      ActiveRecord::Base.transaction do
+        publish_container_sections!(site)
+        publish_container_sections!(page)
+      end
+      true
+    end
+
+    private
+
+    def publish_container_sections!(container)
+      store = find_or_build_published_store(container)
+      store.sections_translations = container.sections_translations
+      store.save!
+    end
+
+    def find_or_build_published_store(container)
+      container.sections_content_stores.find_or_initialize_by(container: container, published: true)
+    end
+  end
+end

data/app/services/maglev/search_pages.rb

@@ -15,9 +15,13 @@ module Maglev
     argument :q, default: nil
     argument :content_locale
     argument :default_locale
+    argument :with_static_pages, default: true
+    argument :index_first, default: false
 
     def call
-      id.nil? ? all_pages : single_page
+      return single_page if id.present?
+
+      with_static_pages ? all_pages : find_persisted_pages
     end
 
     protected
@@ -33,7 +37,7 @@ module Maglev
     end
 
     def find_persisted_pages
-      q ? resources.search(q, content_locale) : resources.all
+      resources.search(q, content_locale, index_first: index_first)
     end
 
     def find_static_pages

data/app/services/maglev/setup_pages.rb

@@ -6,55 +6,76 @@ module Maglev
   class SetupPages
     include Injectable
 
-    dependency :persist_page, class: Maglev::PersistPage
+    dependency :create_page, class: Maglev::CreatePageService
+    dependency :add_section, class: Maglev::Content::AddSectionService
 
     argument :site
     argument :theme
 
     def call
       pages&.map do |page_attributes|
-        create_page(
-          attributes_in_all_locales(page_attributes.with_indifferent_access)
-        )
+        create_page_with_sections(page_attributes)
       end
     end
 
     private
 
     def pages
-      theme&.pages
+      theme&.pages&.map(&:with_indifferent_access)
     end
 
-    def create_page(page_attributes)
-      persist_page.call(
+    def create_page_with_sections(page_attributes)
+      page = create_page.call(
         site: site,
-        site_attributes: site_attributes_from(page_attributes),
-        theme: theme,
-        page: Maglev::Page.new,
-        page_attributes: page_attributes
+        attributes: attributes_in_all_locales(page_attributes)
       )
+
+      throw ActiveRecord::StatementInvalid.new(page.errors.full_messages.join(', ')) if page.errors.any?
+
+      add_sections(page, page_attributes)
+
+      page
     end
 
-    def site_attributes_from(page_attributes)
-      if page_attributes.include?(:sections_translations)
-        { sections_translations: site_sections_translations(page_attributes) }
-      else
-        { sections: select_site_scoped_sections(page_attributes[:sections]) }
-      end.compact || {}
+    def add_sections(page, page_attributes)
+      value_in_all_locales(page_attributes[:sections]).each do |locale, sections_attributes|
+        next if sections_attributes.blank?
+
+        Maglev::I18n.with_locale(locale) do
+          add_sections_in_page(page, sections_attributes)
+        end
+      end
+
+      page.save!
+      site.save!
     end
 
-    def site_sections_translations(page_attributes)
-      sections_translations = page_attributes[:sections_translations].transform_values do |sections|
-        select_site_scoped_sections(sections)
+    def add_sections_in_page(page, sections_attributes)
+      sections_attributes.each do |section_attributes|
+        add_section_in_page(page, section_attributes)
       end
-      sections_translations.any? { |_, sections| sections.blank? } ? nil : sections_translations
+    end
+
+    def add_section_in_page(page, attributes)
+      add_section.call(
+        theme: theme,
+        site: site,
+        page: page,
+        section_type: attributes.fetch('type', nil),
+        content: attributes,
+        dry_run: true
+      )
     end
 
     def attributes_in_all_locales(attributes)
       {
         title_translations: value_in_all_locales(attributes[:title]),
-        sections_translations: value_in_all_locales(attributes[:sections]),
-        path: value_in_all_locales(attributes[:path])
+        path: value_in_all_locales(attributes[:path]),
+        seo_title_translations: value_in_all_locales(attributes[:seo_title]),
+        meta_description_translations: value_in_all_locales(attributes[:meta_description]),
+        og_title_translations: value_in_all_locales(attributes[:og_title]),
+        og_description_translations: value_in_all_locales(attributes[:og_description]),
+        og_image_url_translations: value_in_all_locales(attributes[:og_image_url])
       }
     end
 
@@ -70,15 +91,5 @@ module Maglev
     def fill_translations(value)
       site.locale_prefixes.index_with { |_locale| value }
     end
-
-    def select_site_scoped_sections(sections)
-      (sections || []).find_all do |section|
-        definition = theme.sections.find(section['type'])
-
-        raise "[Maglev] Unknown section type: #{section['type']}" unless definition
-
-        definition.site_scoped?
-      end
-    end
   end
 end