maglevcms 2.0.0 → 3.0.0.beta1

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

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_section_screenshot_url.rb

@@ -8,7 +8,18 @@ module Maglev
     argument :section
 
     def call
-      fetch_section_screenshot_path.call(section: section) + "?#{section.screenshot_timestamp}"
+      screenshot_path = fetch_section_screenshot_path.call(section: section) + query_string
+      asset_host ? URI.join(asset_host, screenshot_path).to_s : screenshot_path
+    end
+
+    private
+
+    def asset_host
+      Rails.application.config.asset_host
+    end
+
+    def query_string
+      "?#{section.screenshot_timestamp}"
     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