iron-cms 0.6.0 → 0.7.1

data/app/models/iron/account/import.rb

@@ -0,0 +1,208 @@
+module Iron
+  class Account::Import < ApplicationRecord
+    include Processable, Broadcastable
+
+    belongs_to :user, class_name: "Iron::User", default: -> { Current.user }
+    has_one_attached :file
+
+    def process_later
+      ImportJob.perform_later(self)
+    end
+
+    def title
+      created_at.strftime("%b %-d, %Y at %-l:%M %p")
+    end
+
+    private
+
+      def perform
+        raise ArgumentError, "Nothing selected to import" unless include_schema? || include_content?
+
+        import_from_zip
+      end
+
+      def import_from_zip
+        Tempfile.create([ "import", ".zip" ]) do |tempfile|
+          tempfile.binmode
+          tempfile.write(file.download)
+          tempfile.rewind
+
+          Zip::File.open(tempfile.path) do |zip|
+            @zip = zip
+            @files_dir = extract_files_to_temp_dir(zip)
+
+            import_schema_from_zip if include_schema?
+            import_content_from_zip if include_content?
+          ensure
+            FileUtils.rm_rf(@files_dir) if @files_dir
+          end
+        end
+      end
+
+      def extract_files_to_temp_dir(zip)
+        dir = Dir.mktmpdir("iron-import")
+        zip.glob("files/**/*").each do |entry|
+          next if entry.directory?
+
+          path = File.join(dir, entry.name.sub("files/", ""))
+          FileUtils.mkdir_p(File.dirname(path))
+          entry.extract(path)
+        end
+        dir
+      end
+
+      def import_schema_from_zip
+        return unless @zip.find_entry("schema.json")
+
+        schema_json = @zip.read("schema.json")
+        schema = parse_json(schema_json)
+        raise ArgumentError, "Invalid schema JSON format" unless schema
+
+        ActiveRecord::Base.transaction do
+          import_block_definitions(schema[:block_definitions] || [])
+          import_content_types(schema[:content_types] || [])
+          resolve_content_type_references(schema[:content_types] || [])
+        end
+      end
+
+      def import_content_from_zip
+        ActiveRecord::Base.transaction do
+          id_mapping = {}
+          entries_data = []
+
+          # First pass: read all entry files and create entries
+          @zip.glob("entries/**/*.json").each do |zip_entry|
+            attrs = parse_json(zip_entry.get_input_stream.read)
+            next unless attrs
+
+            entries_data << attrs
+            entry = Entry.import_from_attributes(attrs, @files_dir)
+            id_mapping[attrs[:id]] = entry if entry
+          end
+
+          # Second pass: resolve references
+          resolve_references(entries_data, id_mapping)
+        end
+      end
+
+      def resolve_references(entries_data, id_mapping)
+        entries_data.each do |attrs|
+          entry = id_mapping[attrs[:id]]
+          next unless entry
+
+          (attrs[:fields] || {}).each do |locale_code, field_data|
+            locale = Locale.find_by(code: locale_code.to_s)
+            next unless locale
+
+            resolve_references_in_fields(entry, locale, field_data, id_mapping)
+          end
+        end
+      end
+
+      def resolve_references_in_fields(entry, locale, fields_data, id_mapping, parent: nil)
+        fields_data.each do |handle, value_data|
+          next unless value_data.is_a?(Hash)
+
+          case value_data[:type]
+          when "reference"
+            resolve_reference_field(entry, locale, handle.to_s, value_data[:value], id_mapping, parent: parent)
+          when "reference_list"
+            resolve_reference_list_field(entry, locale, handle.to_s, value_data[:value], id_mapping, parent: parent)
+          when "block"
+            resolve_references_in_block(entry, locale, handle.to_s, value_data, id_mapping, parent: parent)
+          when "block_list"
+            resolve_references_in_block_list(entry, locale, handle.to_s, value_data, id_mapping, parent: parent)
+          end
+        end
+      end
+
+      def resolve_references_in_block(entry, locale, handle, value_data, id_mapping, parent: nil)
+        block_field = find_field(entry, locale, handle, parent)
+        return unless block_field
+
+        resolve_references_in_fields(entry, locale, value_data[:fields] || {}, id_mapping, parent: block_field)
+      end
+
+      def resolve_references_in_block_list(entry, locale, handle, value_data, id_mapping, parent: nil)
+        block_list_field = find_field(entry, locale, handle, parent)
+        return unless block_list_field
+
+        # Reload blocks and get them in rank order (matching import order)
+        ordered_blocks = block_list_field.blocks.reload.sort_by(&:rank)
+
+        (value_data[:value] || []).each_with_index do |block_data, index|
+          block = ordered_blocks[index]
+          next unless block
+
+          resolve_references_in_fields(entry, locale, block_data[:fields] || {}, id_mapping, parent: block)
+        end
+      end
+
+      def find_field(entry, locale, handle, parent)
+        # Reload associations to get freshly persisted fields from the first pass
+        fields = parent&.fields&.reload || entry.fields.reload
+        definition_scope = parent.is_a?(Fields::Block) ? parent.block_definition.field_definitions : entry.content_type.field_definitions
+        definition = definition_scope.find_by(handle: handle)
+        return unless definition
+
+        fields.find { |f| f.definition_id == definition.id && f.locale_id == locale.id }
+      end
+
+      def resolve_reference_field(entry, locale, handle, old_entry_id, id_mapping, parent: nil)
+        return unless old_entry_id
+
+        referenced_entry = id_mapping[old_entry_id]
+        return unless referenced_entry
+
+        field = find_field(entry, locale, handle, parent)
+        return unless field
+
+        field.update!(referenced_entry: referenced_entry)
+      end
+
+      def resolve_reference_list_field(entry, locale, handle, old_entry_ids, id_mapping, parent: nil)
+        return unless old_entry_ids.is_a?(Array)
+
+        field = find_field(entry, locale, handle, parent)
+        return unless field
+
+        old_entry_ids.each_with_index do |old_id, index|
+          referenced_entry = id_mapping[old_id]
+          next unless referenced_entry
+
+          field.references.create!(entry: referenced_entry, rank: index)
+        end
+      end
+
+      def parse_json(content)
+        JSON.parse(content, symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def import_block_definitions(definitions)
+        definitions.each { |attrs| BlockDefinition.import_from_attributes(attrs) }
+      end
+
+      def import_content_types(definitions)
+        definitions.each { |attrs| ContentType.import_from_attributes(attrs) }
+      end
+
+      def resolve_content_type_references(definitions)
+        definitions.each do |attrs|
+          content_type = ContentType.find_by(handle: attrs[:handle])
+          next unless content_type
+
+          if attrs[:title_field_handle].present?
+            field = content_type.field_definitions.find_by(handle: attrs[:title_field_handle])
+            content_type.update!(title_field_definition: field) if field
+          end
+
+          if attrs[:web_page_title_field_handle].present?
+            field = content_type.field_definitions.find_by(handle: attrs[:web_page_title_field_handle])
+            content_type.update!(web_page_title_field_definition: field) if field
+          end
+        end
+      end
+  end
+end

data/app/models/iron/block_definition/exportable.rb

@@ -0,0 +1,14 @@
+module Iron
+  module BlockDefinition::Exportable
+    extend ActiveSupport::Concern
+
+    def export_attributes
+      {
+        handle:,
+        name:,
+        description:,
+        field_definitions: field_definitions.ranked.map(&:export_attributes)
+      }
+    end
+  end
+end

data/app/models/iron/block_definition/importable.rb

@@ -0,0 +1,27 @@
+module Iron
+  module BlockDefinition::Importable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def import_from_attributes(attrs)
+        block_def = find_or_initialize_by(handle: attrs[:handle])
+        block_def.update!(
+          name: attrs[:name],
+          description: attrs[:description]
+        )
+
+        import_field_definitions(block_def, attrs[:field_definitions] || [])
+
+        block_def
+      end
+
+      private
+
+      def import_field_definitions(block_def, field_attrs_list)
+        field_attrs_list.each do |field_attrs|
+          FieldDefinition.import_from_attributes(field_attrs, schemable: block_def)
+        end
+      end
+    end
+  end
+end

data/app/models/iron/block_definition.rb

@@ -1,6 +1,6 @@
 module Iron
   class BlockDefinition < ApplicationRecord
-    include Portable
+    include Exportable, Importable
 
     has_many :field_definitions, -> { ranked }, as: :schemable, dependent: :destroy
 

data/app/models/iron/content_type/exportable.rb

@@ -0,0 +1,20 @@
+module Iron
+  module ContentType::Exportable
+    extend ActiveSupport::Concern
+
+    def export_attributes
+      {
+        handle:,
+        name:,
+        type: type.demodulize.underscore,
+        description:,
+        icon:,
+        web_publishing_enabled:,
+        base_path:,
+        title_field_handle: title_field_definition&.handle,
+        web_page_title_field_handle: web_page_title_field_definition&.handle,
+        field_definitions: field_definitions.ranked.map(&:export_attributes)
+      }
+    end
+  end
+end

data/app/models/iron/content_type/importable.rb

@@ -0,0 +1,32 @@
+module Iron
+  module ContentType::Importable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def import_from_attributes(attrs)
+        content_type = find_or_initialize_by(handle: attrs[:handle])
+        content_type = content_type.becomes!(classify_type(attrs[:type].camelize).constantize)
+
+        content_type.update!(
+          name: attrs[:name],
+          description: attrs[:description],
+          icon: attrs[:icon],
+          web_publishing_enabled: attrs[:web_publishing_enabled],
+          base_path: attrs[:base_path]
+        )
+
+        import_field_definitions(content_type, attrs[:field_definitions] || [])
+
+        content_type
+      end
+
+      private
+
+      def import_field_definitions(content_type, field_attrs_list)
+        field_attrs_list.each do |field_attrs|
+          FieldDefinition.import_from_attributes(field_attrs, schemable: content_type)
+        end
+      end
+    end
+  end
+end

data/app/models/iron/content_type.rb

@@ -1,6 +1,6 @@
 module Iron
   class ContentType < ApplicationRecord
-    include Titlable, WebPublishable, Portable
+    include Titlable, WebPublishable, Exportable, Importable
 
     TYPES = %w[Single Collection].freeze
 

data/app/models/iron/current.rb

@@ -1,11 +1,14 @@
 module Iron
   class Current < ActiveSupport::CurrentAttributes
-    attribute :session
-    delegate :user, to: :session, allow_nil: true
-
+    attribute :session, :user
     attribute :locale
     attribute :account
 
+    def session=(value)
+      super(value)
+      self.user = value&.user
+    end
+
     def account
       super || (self.account = Account.first)
     end

data/app/models/iron/entry/exportable.rb

@@ -0,0 +1,49 @@
+module Iron
+  module Entry::Exportable
+    extend ActiveSupport::Concern
+    include ActionView::Helpers::TagHelper
+
+    def export_json
+      JSON.pretty_generate(export_attributes)
+    end
+
+    def export_attributes
+      {
+        gid: to_gid.to_s,
+        id: id,
+        content_type_handle: content_type.handle,
+        created_at: created_at.iso8601,
+        updated_at: updated_at.iso8601,
+        route: route,
+        creator_gid: creator&.to_gid&.to_s,
+        fields: export_fields_by_locale
+      }
+    end
+
+    def export_attachments
+      collect_attachments.map do |blob|
+        { path: export_attachment_path(blob), blob: blob }
+      end
+    end
+
+    def export_attachment_path(blob)
+      "#{id}/#{blob.key}_#{blob.filename}"
+    end
+
+    private
+
+      def export_fields_by_locale
+        grouped = fields.includes(:locale, :definition).group_by(&:locale)
+
+        grouped.transform_keys(&:code).transform_values do |locale_fields|
+          locale_fields
+            .reject { |f| f.parent.present? }
+            .to_h { |f| [ f.definition.handle, f.export_value ] }
+        end
+      end
+
+      def collect_attachments
+        fields.flat_map(&:export_attachments).compact
+      end
+  end
+end

data/app/models/iron/entry/importable.rb

@@ -0,0 +1,181 @@
+module Iron
+  module Entry::Importable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def import_from_attributes(attrs, files_dir)
+        content_type = ContentType.find_by(handle: attrs[:content_type_handle])
+        return nil unless content_type
+
+        entry = find_existing_entry(attrs, content_type)
+        entry ||= new(content_type: content_type, creator: find_creator(attrs[:creator_gid]))
+        entry.route = attrs[:route]
+        import_fields(entry, attrs[:fields] || {}, files_dir)
+        entry.save!
+        entry
+      end
+
+      private
+
+        def find_existing_entry(attrs, content_type)
+          find_on_same_instance(attrs[:gid]) || locate_by_route(attrs[:route], content_type)
+        end
+
+        def find_on_same_instance(gid)
+          return unless gid.present?
+
+          ::GlobalID::Locator.locate(gid)
+        rescue ActiveRecord::RecordNotFound
+          nil
+        end
+
+        def locate_by_route(route, content_type)
+          return if route.nil?
+          Entry.find_by(content_type: content_type, route: route)
+        end
+
+        def find_creator(gid)
+          return unless gid.present?
+          ::GlobalID::Locator.locate(gid)
+        rescue ActiveRecord::RecordNotFound
+          nil
+        end
+
+        def import_fields(entry, fields_by_locale, files_dir)
+          fields_by_locale.each do |locale_code, field_data|
+            locale = Locale.find_by(code: locale_code.to_s)
+            next unless locale
+
+            field_data.each do |handle, value_data|
+              next if value_data.nil?
+
+              definition = entry.content_type.field_definitions.find_by(handle: handle.to_s)
+              next unless definition
+
+              import_field(entry, definition, locale, value_data, files_dir)
+            end
+          end
+        end
+
+        def import_field(entry, definition, locale, value_data, files_dir)
+          field = entry.find_or_build_field(definition, locale)
+          import_field_value(field, value_data, entry, files_dir)
+        end
+
+        def import_rich_text_field(field, value_data, files_dir)
+          html = value_data[:value]
+          return unless html.present?
+
+          # Replace local file paths with attached blobs
+          html = replace_file_paths_with_blobs(html, files_dir)
+          field.rich_text = html
+        end
+
+        def import_file_field(field, value_data, files_dir)
+          path = value_data[:value]
+          return unless path.present? && files_dir
+
+          file_path = File.join(files_dir, path)
+          return unless File.exist?(file_path)
+
+          field.file.attach(
+            io: File.open(file_path),
+            filename: File.basename(path).sub(/^[^_]+_/, "")
+          )
+        end
+
+        def import_block_field(entry, field, value_data, files_dir)
+          field.fields.destroy_all if field.persisted?
+          import_block_fields(entry, field, field.block_definition, value_data[:fields] || {}, files_dir)
+        end
+
+        def import_block_list_field(entry, field, value_data, files_dir)
+          return unless value_data[:value].is_a?(Array)
+
+          field.blocks.destroy_all if field.persisted?
+
+          value_data[:value].each_with_index do |block_data, index|
+            import_block(entry, field, block_data, index, files_dir)
+          end
+        end
+
+        def import_block(entry, parent_field, block_data, rank, files_dir)
+          block_definition = BlockDefinition.find_by(handle: block_data[:block_handle])
+          return unless block_definition
+
+          block = parent_field.blocks.build(
+            entry: entry,
+            definition: block_definition,
+            locale: parent_field.locale,
+            rank: rank
+          )
+
+          import_block_fields(entry, block, block_definition, block_data[:fields] || {}, files_dir)
+        end
+
+        def import_block_fields(entry, parent, block_definition, fields_data, files_dir)
+          fields_data.each do |handle, value_data|
+            next if value_data.nil?
+
+            definition = block_definition.field_definitions.find_by(handle: handle.to_s)
+            next unless definition
+
+            nested_field = parent.fields.build(
+              type: definition.field_type,
+              entry: entry,
+              definition: definition,
+              locale: parent.locale
+            )
+
+            import_field_value(nested_field, value_data, entry, files_dir)
+          end
+        end
+
+        def import_field_value(field, value_data, entry, files_dir)
+          case value_data[:type]
+          when "text_field"
+            field.value_string = value_data[:value]
+          when "text_area"
+            field.value_text = value_data[:value]
+          when "number"
+            field.value_float = value_data[:value]
+          when "boolean"
+            field.value_boolean = value_data[:value]
+          when "date"
+            field.value_datetime = value_data[:value].present? ? Time.iso8601(value_data[:value]) : nil
+          when "rich_text_area"
+            import_rich_text_field(field, value_data, files_dir)
+          when "file"
+            import_file_field(field, value_data, files_dir)
+          when "reference", "reference_list"
+            # Skip - resolved in second pass
+          when "block"
+            import_block_field(entry, field, value_data, files_dir)
+          when "block_list"
+            import_block_list_field(entry, field, value_data, files_dir)
+          end
+        end
+
+        def replace_file_paths_with_blobs(html, files_dir)
+          return html unless files_dir
+
+          # Simple regex replacement for src and href attributes pointing to local files
+          html.gsub(/(?:src|href)="(\d+\/[^"]+)"/) do |match|
+            path = $1
+            file_path = File.join(files_dir, path)
+
+            if File.exist?(file_path)
+              filename = File.basename(path).sub(/^[^_]+_/, "")
+              blob = ActiveStorage::Blob.create_and_upload!(
+                io: File.open(file_path),
+                filename: filename
+              )
+              match.sub(path, Rails.application.routes.url_helpers.rails_blob_path(blob, only_path: true))
+            else
+              match
+            end
+          end
+        end
+    end
+  end
+end

data/app/models/iron/entry.rb

@@ -1,6 +1,6 @@
 module Iron
   class Entry < ApplicationRecord
-    include Titlable, Schemable, WebPublishable, Presentable, DeepValidation, InstanceScoped, Portable
+    include Titlable, Schemable, WebPublishable, Presentable, DeepValidation, InstanceScoped, Exportable, Importable
 
     belongs_to :creator, class_name: "Iron::User", default: -> { Current.user }
     has_many :fields, inverse_of: :entry, dependent: :destroy

data/app/models/iron/field.rb

@@ -1,6 +1,6 @@
 module Iron
   class Field < ApplicationRecord
-    include BelongsToEntry, Portable
+    include BelongsToEntry
 
     TYPES = %w[text_field text_area rich_text_area number file boolean date block block_list reference_list reference].freeze
 
@@ -16,5 +16,13 @@ module Iron
     def value
       raise "Field type '#{type}' value method not supported"
     end
+
+    def export_value
+      raise "Field type '#{type}' export_value method not supported"
+    end
+
+    def export_attachments
+      []
+    end
   end
 end

data/app/models/iron/field_definition/exportable.rb

@@ -0,0 +1,23 @@
+module Iron
+  module FieldDefinition::Exportable
+    extend ActiveSupport::Concern
+
+    def export_attributes
+      {
+        handle:,
+        name:,
+        type: type_handle,
+        rank:,
+        metadata:
+      }.tap do |attrs|
+        if respond_to?(:supported_block_definitions)
+          attrs[:supported_block_definitions] = supported_block_definitions.pluck(:handle)
+        end
+
+        if respond_to?(:supported_content_types)
+          attrs[:supported_content_types] = supported_content_types.pluck(:handle)
+        end
+      end.compact_blank
+    end
+  end
+end

data/app/models/iron/field_definition/importable.rb

@@ -0,0 +1,39 @@
+module Iron
+  module FieldDefinition::Importable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def import_from_attributes(attrs, schemable:)
+        raise ArgumentError, "Field type is required" unless attrs[:type].present?
+
+        field_def = schemable.field_definitions.find_or_initialize_by(handle: attrs[:handle])
+        field_def = field_def.becomes!(classify_type(attrs[:type]).constantize)
+
+        field_def.assign_attributes(
+          name: attrs[:name],
+          rank: attrs[:rank],
+          metadata: attrs[:metadata] || {}
+        )
+
+        assign_supported_definitions(field_def, attrs)
+
+        field_def.save!
+        field_def
+      end
+
+      private
+
+      def assign_supported_definitions(field_def, attrs)
+        if field_def.respond_to?(:supported_block_definition_ids=) && attrs[:supported_block_definitions].present?
+          block_defs = BlockDefinition.where(handle: attrs[:supported_block_definitions])
+          field_def.supported_block_definition_ids = block_defs.pluck(:id)
+        end
+
+        if field_def.respond_to?(:supported_content_type_ids=) && attrs[:supported_content_types].present?
+          content_types = ContentType.where(handle: attrs[:supported_content_types])
+          field_def.supported_content_type_ids = content_types.pluck(:id)
+        end
+      end
+    end
+  end
+end

data/app/models/iron/field_definition.rb

@@ -1,6 +1,6 @@
 module Iron
   class FieldDefinition < ApplicationRecord
-    include Portable
+    include Exportable, Importable
 
     TYPES = %w[text_field text_area rich_text_area number file boolean date block block_list reference_list reference].freeze