pageflow 15.0.0.beta2 → 15.0.0.beta3

data/lib/pageflow/entry_export_import/file_mappings.rb

@@ -0,0 +1,32 @@
+module Pageflow
+  module EntryExportImport
+    class FileMappings
+      def initialize
+        @file_mappings = {}
+      end
+
+      def find_or_store(exported_file_id, file_type)
+        imported_file_id = @file_mappings.dig(file_type.model.name, exported_file_id)
+
+        if imported_file_id.present?
+          imported_file_id
+        else
+          file = yield
+
+          @file_mappings[file_type.model.name] ||= {}
+          @file_mappings[file_type.model.name][exported_file_id] = file.id
+
+          file.id
+        end
+      end
+
+      def imported_id_for(model_name, exported_id)
+        @file_mappings.fetch(model_name)[exported_id]
+      end
+
+      def exported_id_for(model_name, imported_id)
+        @file_mappings.fetch(model_name).invert[imported_id]
+      end
+    end
+  end
+end

data/lib/pageflow/entry_export_import/page_type_versions.rb

@@ -0,0 +1,29 @@
+module Pageflow
+  module EntryExportImport
+    # @api private
+    module PageTypeVersions
+      extend self
+
+      class IncompatibleVersionsError < StandardError; end
+
+      def dump
+        Pageflow.config.page_types.each_with_object({}) do |page_type, version_requirements|
+          version_requirements[page_type.name] = page_type.export_version
+        end
+      end
+
+      def verify_compatibility!(data)
+        data.each do |page_type_name, export_version|
+          page_type = Pageflow.config.page_types.find_by_name!(page_type_name)
+          requirement = Gem::Requirement.new(page_type.import_version_requirement)
+
+          next if requirement.satisfied_by?(Gem::Version.new(export_version))
+
+          raise(IncompatibleVersionsError,
+                "Export version #{export_version} of page type #{page_type_name}. " \
+                "does not match #{requirement}")
+        end
+      end
+    end
+  end
+end

data/lib/pageflow/entry_export_import/revision_serialization.rb

@@ -0,0 +1,58 @@
+module Pageflow
+  module EntryExportImport
+    # Turn revision into JSON compatible data structure.
+    module RevisionSerialization
+      extend self
+
+      SERIALIZE_OPTIONS = {
+        except: [:entry_id, :creator_id],
+        include: {
+          widgets: {
+            except: [:subject_id, :subject_type]
+          },
+          storylines: {
+            except: :revision_id,
+            include: {
+              chapters: {
+                except: :storyline_id,
+                include: {
+                  pages: {
+                    except: :chapter_id
+                  }
+                }
+              }
+            }
+          },
+          file_usages: {
+            except: [:revision_id],
+            include: {
+              file: {
+                except: [:entry_id, :job_id]
+              }
+            }
+          }
+        }
+      }.freeze
+
+      def dump(revision)
+        revision
+          .as_json(SERIALIZE_OPTIONS)
+          .merge('components' => serialize_revision_components(revision))
+      end
+
+      def import(data, options)
+        Import.new(options).perform(data)
+      end
+
+      private
+
+      def serialize_revision_components(revision)
+        revision.find_revision_components.map do |revision_component|
+          revision_component
+            .attributes.except('revision_id')
+            .merge('class_name' => revision_component.class.name)
+        end
+      end
+    end
+  end
+end

data/lib/pageflow/entry_export_import/revision_serialization/import.rb

@@ -0,0 +1,158 @@
+module Pageflow
+  module EntryExportImport
+    module RevisionSerialization
+      # Turn revision into JSON compatible data structure.
+      class Import
+        DEFAULT_REMOVAL_COLUMNS = %w[id updated_at].freeze
+        COMMON_FILE_COLUMNS = %w[entry_id rights created_at uploader_id
+                                 confirmed_by_id parent_file_id parent_file_model_type].freeze
+
+        def initialize(entry:, creator:, file_mappings: FileMappings.new)
+          @entry = entry
+          @creator = creator
+          @file_mappings = file_mappings
+        end
+
+        def perform(data)
+          Revision.transaction do
+            revision = create_revision(data)
+
+            create_storylines_chapters_and_pages(revision, data['storylines'])
+            create_widgets(revision, data['widgets'])
+            create_revision_components(revision, data['components'])
+            create_files(revision, data['file_usages'])
+
+            revision
+          end
+        end
+
+        private
+
+        attr_reader :entry, :creator, :file_mappings
+
+        def create_revision(data)
+          revision_attributes = data.except('storylines',
+                                            'file_usages',
+                                            'widgets',
+                                            'components',
+                                            *DEFAULT_REMOVAL_COLUMNS)
+
+          unless Pageflow.config_for(entry).themes.names.include?(revision_attributes['theme_name'])
+            revision_attributes['theme_name'] = 'default'
+          end
+
+          entry.revisions.create!(revision_attributes.merge(creator: creator)) do |revision|
+            revision.published_until = Time.now if revision.published?
+          end
+        end
+
+        def create_storylines_chapters_and_pages(revision, storylines_data)
+          storylines_data.each do |storyline_data|
+            chapters_data = storyline_data.delete('chapters')
+            storyline = revision.storylines.create!(storyline_data.except(*DEFAULT_REMOVAL_COLUMNS))
+
+            create_chapters_and_pages(storyline, chapters_data)
+          end
+        end
+
+        def create_chapters_and_pages(storyline, chapters_data)
+          chapters_data.each do |chapter_data|
+            pages_data = chapter_data.delete('pages')
+            chapter = storyline.chapters.create!(chapter_data.except(*DEFAULT_REMOVAL_COLUMNS))
+
+            create_pages(chapter, pages_data)
+          end
+        end
+
+        def create_pages(chapter, pages_data)
+          pages_data.each do |page_data|
+            chapter.pages.create!(page_data.except(*DEFAULT_REMOVAL_COLUMNS))
+          end
+        end
+
+        def create_widgets(revision, widgets_data)
+          widgets_data.each do |widget_data|
+            revision.widgets.create!(widget_data.except(*DEFAULT_REMOVAL_COLUMNS))
+          end
+        end
+
+        def create_revision_components(revision, revision_components_data)
+          revision_components_data.each do |component_data|
+            component_model = component_data.delete('class_name').constantize
+            component_data['revision_id'] = revision.id
+            component_model.create!(component_data.except(*DEFAULT_REMOVAL_COLUMNS))
+          end
+        end
+
+        def create_files(revision, file_usages_data)
+          Pageflow.config.file_types.each do |file_type|
+            filter_by_file_type(file_usages_data, file_type).each do |file_type_usage_data|
+              file_data = file_type_usage_data.delete('file')
+
+              file_type_usage_data['file_id'] =
+                file_mappings.find_or_store(file_data['id'], file_type) do
+                  create_file(file_data, file_type)
+                end
+
+              revision.file_usages.create!(file_type_usage_data.except(*DEFAULT_REMOVAL_COLUMNS))
+            end
+          end
+        end
+
+        def filter_by_file_type(file_usages_data, file_type)
+          file_usages_data.select do |file_usage|
+            file_usage['file_type'].eql?(file_type.type_name)
+          end
+        end
+
+        def create_file(file_data, file_type)
+          rewrite_entry_reference(file_data)
+          rewrite_user_references(file_data)
+          rewrite_parent_file_reference(file_data)
+          custom_file_attribute_names = rewrite_custom_attributes(file_data, file_type)
+
+          file_type.model.create!(file_data.slice(*COMMON_FILE_COLUMNS,
+                                                  *custom_file_attribute_names)) do |file|
+            assign_attachments_attributes(file, file_data)
+          end
+        end
+
+        def rewrite_entry_reference(file_data)
+          file_data['entry_id'] = entry.id
+        end
+
+        def rewrite_user_references(file_data)
+          file_data['uploader_id'] = creator.id if file_data['uploader_id'].present?
+          file_data['confirmed_by_id'] = creator.id if file_data['confirmed_by_id'].present?
+        end
+
+        def rewrite_parent_file_reference(file_data)
+          rewrite_foreign_key(file_data, 'parent_file_id', file_data['parent_file_model_type'])
+        end
+
+        def rewrite_custom_attributes(file_data, file_type)
+          file_type.custom_attributes.stringify_keys.map do |attribute_name, options|
+            rewrite_foreign_key(file_data, attribute_name, options[:model]) if options[:model]
+            attribute_name
+          end
+        end
+
+        def rewrite_foreign_key(attributes, attribute_name, model_name)
+          exported_id = attributes[attribute_name]
+          return unless exported_id
+
+          attributes[attribute_name] = file_mappings.imported_id_for(model_name, exported_id)
+        end
+
+        def assign_attachments_attributes(file, file_data)
+          file.attachments_for_export.each do |attachment|
+            file.assign_attributes(file_data.slice("#{attachment.name}_file_name",
+                                                   "#{attachment.name}_content_type",
+                                                   "#{attachment.name}_file_size",
+                                                   "#{attachment.name}_updated_at"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pageflow/entry_export_import/zip_archive.rb

@@ -0,0 +1,36 @@
+require 'zip'
+
+module Pageflow
+  module EntryExportImport
+    # Read and write files from and to zip archives
+    class ZipArchive
+      def initialize(file_name)
+        @file = Zip::File.open(file_name, Zip::File::CREATE)
+      end
+
+      def include?(path)
+        @file.find_entry(path).present?
+      end
+
+      def glob(pattern)
+        @file.glob(pattern).map(&:name)
+      end
+
+      def add(path, stream)
+        @file.get_output_stream(path) { |f| IO.copy_stream(stream, f) }
+      end
+
+      def extract_to_tempfile(path)
+        Tempfile.open do |f|
+          IO.copy_stream(@file.get_input_stream(path), f)
+          f.rewind
+          yield f
+        end
+      end
+
+      def close
+        @file.close
+      end
+    end
+  end
+end

data/lib/pageflow/file_type.rb

@@ -51,8 +51,7 @@ module Pageflow
     # @return [#call]
     attr_reader :url_templates
 
-    # Attributes that are custom to this file type.
-    # @return {Array<Symbol>}
+    # @api private
     attr_reader :custom_attributes
 
     # Create file type to be returned in {PageType#file_types}.
@@ -93,8 +92,8 @@ module Pageflow
       @top_level_type = options.fetch(:top_level_type, false)
       @css_background_image_urls = options[:css_background_image_urls]
       @css_background_image_class_prefix = options[:css_background_image_class_prefix]
-      @url_templates = options.fetch(:url_templates, ->() { {} })
-      @custom_attributes = options.fetch(:custom_attributes, [])
+      @url_templates = options.fetch(:url_templates, -> { {} })
+      @custom_attributes = convert_custom_attributes_option(options[:custom_attributes])
     end
 
     # ActiveRecord model that represents the files of this type.
@@ -140,5 +139,19 @@ module Pageflow
     def i18n_key
       model.model_name.i18n_key
     end
+
+    private
+
+    def convert_custom_attributes_option(custom_attributes)
+      if custom_attributes.is_a?(Array)
+        custom_attributes.each_with_object({}) do |attribute_name, result|
+          result[attribute_name] = {permitted_create_param: true}
+        end
+      elsif custom_attributes.is_a?(Hash)
+        custom_attributes
+      else
+        {}
+      end
+    end
   end
 end

data/lib/pageflow/page_type.rb

@@ -94,6 +94,26 @@ module Pageflow
       []
     end
 
+    # Current plugin version
+    def export_version
+      "Pageflow::#{name.camelize}::VERSION".constantize
+    rescue NameError
+      begin
+        "#{name.camelize}::VERSION".constantize
+      rescue NameError
+        raise "PageType #{name} needs to define export_version."
+      end
+    end
+
+    # Gets included in JSON file during export of an entry.
+    # The host application needs to compare this version with the version (above)
+    # for each page type before importing.
+    # Defaults to the plugins version but can be overwritten during registry of the page type,
+    # using the same notation as version requirements in the Gemfile.
+    def import_version_requirement
+      export_version
+    end
+
     # A list of hashes used to determine a thumbnail for a page. Each
     # hash in the list must contain two keys: `attribute` and
     # `file_collection`.

data/lib/pageflow/page_types.rb

@@ -14,6 +14,8 @@ module Pageflow
     def register(page_type)
       @page_types << page_type
       @page_types_by_name[page_type.name] = page_type
+
+      ensure_export_version_implemented(page_type)
     end
 
     def find_by_name!(name)
@@ -29,5 +31,11 @@ module Pageflow
     def each(&block)
       @page_types.each(&block)
     end
+
+    private
+
+    def ensure_export_version_implemented(page_type)
+      page_type.export_version
+    end
   end
 end

data/lib/pageflow/react/page_type.rb

@@ -8,6 +8,8 @@ module Pageflow
         @thumbnail_candidates = options[:thumbnail_candidates]
         @translation_key_prefix = options[:translation_key_prefix]
         @file_types = options.fetch(:file_types, [])
+        @export_version = options[:export_version]
+        @import_version_requirement = options[:import_version_requirement]
       end
 
       def template_path
@@ -21,6 +23,14 @@ module Pageflow
       def translation_key_prefix
         @translation_key_prefix || super
       end
+
+      def export_version
+        @export_version || super
+      end
+
+      def import_version_requirement
+        @import_version_requirement || super
+      end
     end
   end
 end

data/lib/pageflow/version.rb

@@ -1,3 +1,3 @@
 module Pageflow
-  VERSION = '15.0.0.beta2'.freeze
+  VERSION = '15.0.0.beta3'.freeze
 end

data/lib/pageflow/widget_types.rb

@@ -10,7 +10,6 @@ module Pageflow
 
     def register(widget_type, options = {})
       @widget_types[widget_type.name] = widget_type
-
       if options[:default]
         widget_type.roles.each do |role|
           defaults_by_role[role] = widget_type
@@ -18,9 +17,14 @@ module Pageflow
       end
     end
 
+    def register_widget_defaults(widget_role, default_configurations)
+      @default_configurations[widget_role] = default_configurations
+    end
+
     def clear
       @widget_types = {}
       @defaults_by_role = {}
+      @default_configurations = {}
     end
 
     def each(&block)
@@ -37,6 +41,10 @@ module Pageflow
       @widget_types.fetch(name, &block)
     end
 
+    def default_configuration(name)
+      @default_configurations[name]
+    end
+
     def find_all_by_role(role)
       select do |widget_type|
         widget_type.roles.include?(role)