iron-cms 0.1.2 → 0.2.0

data/app/models/iron/content_import/field_snapshot.rb

@@ -0,0 +1,33 @@
+module Iron
+  class ContentImport::FieldSnapshot
+      attr_reader :locale_code, :path, :value
+
+      def initialize(locale_code:, path:, value:)
+        @locale_code = locale_code
+        @path = path
+        @value = value
+      end
+
+      def field_handle
+        return nil unless field_path?
+
+        segments[0]
+      end
+
+      def field_segments
+        return [] unless field_path?
+
+        segments
+      end
+
+      def field_path?
+        @path&.start_with?("/fields/")
+      end
+
+      private
+
+        def segments
+          @segments ||= @path.sub(%r{^/fields/}, "").split("/")
+        end
+  end
+end

data/app/models/iron/content_import/registry.rb

@@ -0,0 +1,32 @@
+module Iron
+  class ContentImport::Registry
+      def initialize
+        @entries_by_original_gid = {}
+      end
+
+      def register_entry(original_gid, entry)
+        @entries_by_original_gid[original_gid] = entry
+        @entries_by_original_gid[entry.to_gid.to_s] = entry
+      end
+
+      def find_entry(gid_string)
+        return nil if gid_string.blank?
+
+        cached_entry = @entries_by_original_gid[gid_string]
+        return cached_entry if cached_entry
+
+        locate_existing_entry(gid_string)
+      end
+
+      private
+
+        def locate_existing_entry(gid_string)
+          entry = ::GlobalID::Locator.locate(gid_string)
+          return nil unless entry.is_a?(Iron::Entry)
+
+          @entries_by_original_gid[gid_string] = entry
+        rescue ActiveRecord::RecordNotFound
+          nil
+        end
+  end
+end

data/app/models/iron/content_import/session.rb

@@ -0,0 +1,89 @@
+require "csv"
+
+module Iron
+  class ContentImport::Session
+      attr_reader :errors
+
+      def initialize(archive)
+        raise ArgumentError, "Missing import archive" unless archive.present?
+
+        @archive = archive
+        @errors = []
+        @registry = ContentImport::Registry.new
+      end
+
+      def run
+        ActiveRecord::Base.transaction do
+          prepare_entries
+          reconstruct_entries
+
+          Result.new(success: true)
+        end
+      rescue StandardError => e
+        warn e.full_message
+        @errors << "Import failed: #{e.message}"
+        Result.new(success: false, errors: @errors)
+      end
+
+      private
+
+        def prepare_entries
+          content_manifests.each do |content_type, csv_data|
+            entry_builder = ContentImport::EntryBuilder.new(content_type, @registry)
+            entry_builder.ensure_entries_exist(csv_data)
+          end
+        end
+
+        def reconstruct_entries
+          content_manifests.each do |content_type, csv_data|
+            reconstructor = ContentImport::FieldReconstructor.new(content_type, @registry, @archive)
+            reconstructor.reconstruct_all(csv_data)
+          end
+        end
+
+        def content_manifests
+          @content_manifests ||= build_content_manifests
+        end
+
+        def build_content_manifests
+          @archive.file_paths
+            .select { |path| content_manifest?(path) }
+            .sort
+            .filter_map do |path|
+              content_type = find_content_type(path)
+
+              unless content_type
+                @errors << "Unknown content type '#{extract_handle(path)}' in archive"
+                next
+              end
+
+              [ content_type, @archive[path] ]
+            end
+        end
+
+        def content_manifest?(path)
+          path.start_with?("content/") && path.end_with?(".csv")
+        end
+
+        def extract_handle(path)
+          ::File.basename(path, ".csv")
+        end
+
+        def find_content_type(path)
+          Iron::ContentType.find_by(handle: extract_handle(path))
+        end
+
+      class Result
+        attr_reader :errors
+
+        def initialize(success:, errors: [])
+          @success = success
+          @errors = errors
+        end
+
+        def success?
+          @success
+        end
+      end
+  end
+end

data/app/models/iron/content_import.rb

@@ -0,0 +1,15 @@
+module Iron
+  class ContentImport
+    def self.import(archive)
+      new(archive).import
+    end
+
+    def initialize(archive)
+      @archive = archive
+    end
+
+    def import
+      Session.new(@archive).run
+    end
+  end
+end

data/app/models/iron/content_type.rb

@@ -11,6 +11,14 @@ module Iron
 
     has_many :entries, -> { extending FieldQueryable }, dependent: :destroy
 
+    has_and_belongs_to_many :referencing_field_definitions,
+      class_name: "::Iron::FieldDefinition",
+      foreign_key: "content_type_id",
+      association_foreign_key: "field_definition_id",
+      join_table: "iron_content_types_field_definitions"
+
+    before_destroy { referencing_field_definitions.clear }
+
     class << self
       def classify_type(type)
         "Iron::ContentTypes::#{type}"

data/app/models/iron/current.rb

@@ -4,9 +4,10 @@ module Iron
     delegate :user, to: :session, allow_nil: true
 
     attribute :locale
+    attribute :account
 
     def account
-      Account.first
+      super || (self.account = Account.first)
     end
   end
 end

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

@@ -0,0 +1,35 @@
+module Iron
+  class Entry
+    module Portable
+      extend ActiveSupport::Concern
+
+      def to_csv_rows
+        rows = []
+
+        rows.concat(entry_attribute_rows)
+
+        fields.where(parent_type: nil).includes(:locale, :definition).each do |field|
+          rows.concat(field.to_csv_rows)
+        end
+
+        rows
+      end
+
+      private
+
+        def entry_attribute_rows
+          rows = []
+
+          rows << csv_row("/created_at", "date", created_at.iso8601)
+          rows << csv_row("/updated_at", "date", updated_at.iso8601)
+          rows << csv_row("/route", "text", route) unless route.nil?
+
+          rows
+        end
+
+        def csv_row(path, type, value)
+          [ to_gid, nil, path, type, value ]
+        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
+    include Titlable, Schemable, WebPublishable, Presentable, DeepValidation, InstanceScoped, Portable
 
     belongs_to :creator, class_name: "Iron::User", default: -> { Current.user }
     has_many :fields, inverse_of: :entry, dependent: :destroy

data/app/models/iron/field/portable.rb

@@ -0,0 +1,33 @@
+module Iron
+  class Field
+    module Portable
+      extend ActiveSupport::Concern
+
+      def to_csv_rows
+        [ csv_row(field_path, csv_type, csv_value) ]
+      end
+
+      def field_path
+        if parent.is_a?(Fields::Block)
+          "#{parent.field_path}/#{definition.handle}"
+        elsif parent.is_a?(Fields::BlockList)
+          "#{parent.field_path}/#{rank}"
+        else
+          "/fields/#{definition.handle}"
+        end
+      end
+
+      def csv_row(path, type, value = nil)
+        [ entry.to_gid, locale&.code, path, type, value ]
+      end
+
+        def csv_type
+          raise NotImplementedError, "#{self.class} must implement csv_type"
+        end
+
+        def csv_value
+          raise NotImplementedError, "#{self.class} must implement csv_value"
+        end
+    end
+  end
+end

data/app/models/iron/field.rb

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

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

@@ -5,7 +5,7 @@ module Iron
 
     class_methods do
       def csv_headers
-        %w[parent_type parent_handle handle name type rank metadata supported_block_definitions]
+        %w[parent_type parent_handle handle name type rank metadata supported_block_definitions supported_content_types]
       end
 
       def csv_scope
@@ -22,15 +22,21 @@ module Iron
         type.demodulize.underscore,
         rank,
         metadata.to_json,
-        export_supported_block_definitions
+        export_supported_block_definitions,
+        export_supported_content_types
       ]
     end
 
     private
 
-    def export_supported_block_definitions
-      return nil unless respond_to?(:supported_block_definitions)
-      supported_block_definitions.pluck(:handle).join("|")
-    end
+      def export_supported_block_definitions
+        return nil unless respond_to?(:supported_block_definitions)
+        supported_block_definitions.pluck(:handle).join("|")
+      end
+
+      def export_supported_content_types
+        return nil unless respond_to?(:supported_content_types)
+        supported_content_types.pluck(:handle).join("|")
+      end
   end
 end

data/app/models/iron/fields/block.rb

@@ -6,7 +6,15 @@ module Iron
     has_rank scoped_by: :parent
 
     def block_list
-      parent.is_a?(Iron::Fields::BlockList) ? parent : nil
+      parent.is_a?(Fields::BlockList) ? parent : nil
+    end
+
+    def block_definition
+      if definition.is_a?(FieldDefinitions::Block)
+        definition.supported_block_definition
+      else
+        definition
+      end
     end
 
     def find_or_build_field(definition)
@@ -14,13 +22,7 @@ module Iron
     end
 
     def value
-      locale = Iron::Current.locale || Iron::Locale.default
-
-      block_definition = if definition.is_a?(Iron::FieldDefinitions::Block)
-        definition.supported_block_definition
-      else
-        definition
-      end
+      locale = Current.locale || Locale.default
 
       result = OpenStruct.new(id: id, _type: block_definition.handle)
 
@@ -36,5 +38,17 @@ module Iron
 
       result
     end
+
+    def to_csv_rows
+      rows = []
+
+      rows << csv_row("#{field_path}/_block", "text", block_definition.handle)
+
+      fields.includes(:locale, :definition).each do |nested_field|
+        rows.concat(nested_field.to_csv_rows)
+      end
+
+      rows
+    end
   end
 end

data/app/models/iron/fields/block_list.rb

@@ -12,5 +12,15 @@ module Iron
     def value
       blocks.map(&:value)
     end
+
+    def to_csv_rows
+      rows = []
+
+      blocks.includes(:fields, :locale, :definition).each do |block|
+        rows.concat(block.to_csv_rows)
+      end
+
+      rows
+    end
   end
 end

data/app/models/iron/fields/boolean.rb

@@ -3,5 +3,15 @@ module Iron
     def value
       value_boolean
     end
+
+    private
+
+      def csv_type
+        "boolean"
+      end
+
+      def csv_value
+        value_boolean&.to_s
+      end
   end
 end

data/app/models/iron/fields/date.rb

@@ -3,5 +3,15 @@ module Iron
     def value
       value_datetime
     end
+
+    private
+
+      def csv_type
+        "date"
+      end
+
+      def csv_value
+        value_datetime&.iso8601
+      end
   end
 end

data/app/models/iron/fields/file.rb

@@ -25,5 +25,13 @@ module Iron
           errors.add(:base, "must be one of the accepted formats: #{definition.accepted_extensions.join(', ')}")
         end
       end
+
+      def csv_type
+        "file"
+      end
+
+      def csv_value
+        file.attached? ? file.blob.id : nil
+      end
   end
 end

data/app/models/iron/fields/number.rb

@@ -3,5 +3,15 @@ module Iron
     def value
       value_float
     end
+
+    private
+
+      def csv_type
+        "number"
+      end
+
+      def csv_value
+        value_float&.to_s
+      end
   end
 end

data/app/models/iron/fields/reference.rb

@@ -10,5 +10,15 @@ module Iron
         )
       end
     end
+
+    private
+
+      def csv_type
+        "reference"
+      end
+
+      def csv_value
+        referenced_entry&.to_gid
+      end
   end
 end

data/app/models/iron/fields/reference_list.rb

@@ -13,5 +13,19 @@ module Iron
         )
       end
     end
+
+    def to_csv_rows
+      rows = []
+
+      references.includes(:entry).each do |reference|
+        rows << csv_row(
+          "#{field_path}/#{reference.rank}",
+          "reference",
+          reference.entry.to_gid
+        )
+      end
+
+      rows
+    end
   end
 end

data/app/models/iron/fields/rich_text_area.rb

@@ -5,5 +5,31 @@ module Iron
     def value
       rich_text&.to_s
     end
+
+    def to_csv_rows
+      rows = []
+
+      if rich_text.present?
+        rows << csv_row("#{field_path}/html", "rich_text", rich_text.body&.to_html)
+
+        rich_text.body.attachables.each do |attachable|
+          next unless attachable.respond_to?(:blob)
+
+          rows << csv_row("#{field_path}/attachments", "reference", attachable.blob.id)
+        end
+      end
+
+      rows
+    end
+
+    private
+
+      def csv_type
+        "rich_text"
+      end
+
+      def csv_value
+        rich_text.body&.to_html
+      end
   end
 end

data/app/models/iron/fields/text_area.rb

@@ -3,5 +3,15 @@ module Iron
     def value
       value_text
     end
+
+    private
+
+      def csv_type
+        "text"
+      end
+
+      def csv_value
+        value_text
+      end
   end
 end

data/app/models/iron/fields/text_field.rb

@@ -15,5 +15,13 @@ module Iron
           errors.add(:base, :blank)
         end
       end
+
+      def csv_type
+        "text"
+      end
+
+      def csv_value
+        value_string
+      end
   end
 end

data/app/models/iron/locale.rb

@@ -11,7 +11,7 @@ module Iron
     end
 
     def self.default
-      Account.first&.default_locale
+      Current.account&.default_locale
     end
 
     def default?

data/app/models/iron/schema_importer/import_strategy.rb

@@ -0,0 +1,59 @@
+module Iron
+  class SchemaImporter::ImportStrategy
+    def import_block_definition(row)
+      raise NotImplementedError
+    end
+
+    def import_content_type(row)
+      raise NotImplementedError
+    end
+
+    def import_field_definition(row)
+      raise NotImplementedError
+    end
+
+    protected
+
+      def find_parent(parent_type, parent_handle)
+        case parent_type
+        when "content_type"
+          ContentType.find_by(handle: parent_handle)
+        when "block"
+          BlockDefinition.find_by(handle: parent_handle)
+        end
+      end
+
+      def content_type_class(type)
+        case type
+        when "single" then ContentTypes::Single
+        when "collection" then ContentTypes::Collection
+        else
+          raise "Invalid content type: #{type}. Must be 'single' or 'collection'"
+        end
+      end
+
+      def field_definition_class(type)
+        "Iron::FieldDefinitions::#{type.camelize}".constantize
+      end
+
+      def parse_metadata(metadata_string)
+        return {} if metadata_string.blank?
+
+        JSON.parse(metadata_string)
+      rescue JSON::ParserError
+        {}
+      end
+
+      def parse_supported_block_definitions(supported_handles_string)
+        return BlockDefinition.none unless supported_handles_string.present?
+
+        BlockDefinition.where(handle: supported_handles_string.split("|"))
+      end
+
+      def parse_supported_content_types(supported_handles_string)
+        return ContentType.none unless supported_handles_string.present?
+
+        ContentType.where(handle: supported_handles_string.split("|"))
+      end
+  end
+end

data/app/models/iron/schema_importer/merge_strategy.rb

@@ -0,0 +1,52 @@
+module Iron
+  class SchemaImporter::MergeStrategy < SchemaImporter::ImportStrategy
+    def import_block_definition(row)
+      definition = BlockDefinition.find_or_initialize_by(handle: row["handle"])
+      definition.update!(
+        name: row["name"],
+        description: row["description"]
+      )
+    end
+
+    def import_content_type(row)
+      content_type = ContentType.find_or_initialize_by(handle: row["handle"])
+
+      content_type = content_type.becomes!(content_type_class(row["type"]))
+      content_type.update!(
+        name: row["name"],
+        description: row["description"],
+        icon: row["icon"],
+        web_publishing_enabled: row["web_publishing_enabled"] == "true",
+        base_path: row["base_path"]
+      )
+    end
+
+    def import_field_definition(row)
+      raise "Field type is required" unless row["type"].present?
+      return unless row["parent_type"].present? && row["parent_handle"].present? && row["handle"].present?
+
+      parent = find_parent(row["parent_type"], row["parent_handle"])
+      return unless parent
+
+      field_def = parent.field_definitions.find_or_initialize_by(handle: row["handle"])
+      field_def = field_def.becomes!(field_definition_class(row["type"]))
+
+      attributes = {
+        name: row["name"],
+        rank: row["rank"],
+        metadata: parse_metadata(row["metadata"])
+      }
+
+      if field_def.is_a?(FieldDefinitions::Block) || field_def.is_a?(FieldDefinitions::BlockList)
+        attributes[:supported_block_definition_ids] = parse_supported_block_definitions(row["supported_block_definitions"]).pluck(:id)
+      end
+
+      if field_def.is_a?(FieldDefinitions::Reference) || field_def.is_a?(FieldDefinitions::ReferenceList)
+        attributes[:supported_content_type_ids] = parse_supported_content_types(row["supported_content_types"]).pluck(:id)
+      end
+
+      field_def.assign_attributes(attributes)
+      field_def.save!
+    end
+  end
+end