spina-admin-conferences-fork 2.1.1

data/db/migrate/20201002122517_remove_spina_conferences_conference_page_parts.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class RemoveSpinaConferencesConferencePageParts < ActiveRecord::Migration[6.0]
+  def change
+    drop_table :spina_conferences_conference_page_parts do |t|
+      t.references :conference_page, foreign_key: { to_table: :spina_pages, on_delete: :cascade },
+                                     index: { name: 'index_spina_conferences_parts_on_page_id' }
+      t.references :conference_page_partable, polymorphic: true,
+                                              index: { name: 'index_spina_conferences_parts_on_partable_type_and_partable_id' }
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20201007125625_add_timestamps_to_spina_conferences_parts.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class AddTimestampsToSpinaConferencesParts < ActiveRecord::Migration[6.0]
+  def change
+    default = Time.now
+    add_timestamps :spina_conferences_parts, default: default
+    change_column_default :spina_conferences_parts, :created_at, from: default, to: nil
+    change_column_default :spina_conferences_parts, :updated_at, from: default, to: nil
+  end
+end

data/db/migrate/20210315164409_add_json_attributes_to_spina_conferences_presentations.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddJsonAttributesToSpinaConferencesPresentations < ActiveRecord::Migration[6.1] # :nodoc:
+  def change
+    add_column :spina_conferences_presentations, :json_attributes, :jsonb
+  end
+end

data/db/migrate/20210315164410_add_json_attributes_to_spina_conferences_conferences.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddJsonAttributesToSpinaConferencesConferences < ActiveRecord::Migration[6.1] # :nodoc:
+  def change
+    add_column :spina_conferences_conferences, :json_attributes, :jsonb
+  end
+end

data/db/migrate/20210315164411_convert_partables_to_json.rb

@@ -0,0 +1,407 @@
+# frozen_string_literal: true
+
+# Reregistering parts necessary due to deserialization from JSON, where class instances from registration used
+Spina::Part.all.delete_if { |part| Spina::Parts::Admin::Conferences.constants.include? :"#{part.name.demodulize}" }
+Spina::Part.register(Spina::Parts::Admin::Conferences::Date)
+Spina::Part.register(Spina::Parts::Admin::Conferences::EmailAddress)
+Spina::Part.register(Spina::Parts::Admin::Conferences::Time)
+Spina::Part.register(Spina::Parts::Admin::Conferences::Url)
+
+# This migration converts table-based partables from Spina v1 to the new JSON-based parts in Spina v2.
+# If you have custom partables you must modify this migration to ensure the conversion of your partables is handled appropriately
+# by implementing <tt>convert_to_json!</tt> for your partables.
+class ConvertPartablesToJson < ActiveRecord::Migration[6.1]
+  def up # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    announce 'converting partables to JSON parts'
+    Spina.config.locales.each do |locale|
+      I18n.with_locale(locale) do
+        say_with_time "Migrating content in locale #{I18n.locale}..." do
+          Spina::Page.in_batches.each_record do |page|
+            say "Migrating page parts for \"#{page.title}\"...", true
+            page.convert_page_parts_to_json!
+          end
+          Spina::Account.in_batches.each_record do |account|
+            say "Migrating layout parts for \"#{account.name}\"...", true
+            account.convert_layout_parts_to_json!
+          end
+          Spina::Admin::Conferences::Conference.in_batches.each_record do |conference|
+            say "Migrating parts for \"#{conference.name}\"...", true
+            conference.convert_parts_to_json!
+          end
+          Spina::Admin::Conferences::Presentation.in_batches.each_record do |presentation|
+            say "Migrating parts for \"#{presentation.title}\"...", true
+            presentation.convert_parts_to_json!
+          end
+        end
+      end
+    end
+  end
+
+  def down # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    announce 'converting JSON parts to partables'
+    Spina.config.locales.each do |locale|
+      I18n.with_locale(locale) do
+        say_with_time "Migrating content in locale #{I18n.locale}..." do
+          Spina::Page.in_batches.each_record do |page|
+            say "Migrating JSON parts for \"#{page.title}\"...", true
+            page.convert_json_to_parts!
+          end
+          Spina::Account.in_batches.each_record do |account|
+            say "Migrating JSON parts for \"#{account.name}\"...", true
+            account.convert_json_to_parts!
+          end
+          Spina::Admin::Conferences::Conference.in_batches.each_record do |conference|
+            say "Migrating JSON parts for \"#{conference.name}\"...", true
+            conference.convert_json_to_parts!
+          end
+          Spina::Admin::Conferences::Presentation.in_batches.each_record do |presentation|
+            say "Migrating JSON parts for \"#{presentation.title}\"...", true
+            presentation.convert_json_to_parts!
+          end
+        end
+      end
+    end
+  end
+end
+
+module Spina # :nodoc: all
+  class ImageCollectionsImage < Spina::ApplicationRecord
+    belongs_to :image
+    belongs_to :image_collection
+  end
+
+  class AttachmentCollectionsAttachment < Spina::ApplicationRecord
+    belongs_to :attachment
+    belongs_to :attachment_collection
+  end
+
+  class Attachment < ApplicationRecord
+    def convert_to_json!
+      Parts::Attachment.new(attachment_id: id, signed_blob_id: file.blob.signed_id, filename: file.blob.filename)
+    end
+  end
+
+  class AttachmentCollection < ApplicationRecord
+    has_many :attachment_collection_attachments
+    has_many :attachments, through: :attachment_collection_attachments
+
+    def convert_to_json!
+      Parts::Repeater.new(content: attachments.collect(&:convert_to_json!)
+                                              .collect { |attachment| RepeaterContent.new(parts: [attachment]) })
+    end
+  end
+
+  class Image < ApplicationRecord
+    def convert_to_json!
+      Parts::Image.new(image_id: id, signed_blob_id: file.blob.signed_id, filename: file.blob.filename)
+    end
+  end
+
+  class ImageCollection < ApplicationRecord
+    has_many :image_collections_images
+    has_many :images, through: :image_collections_images
+
+    def convert_to_json!
+      Parts::ImageCollection.new(images: images.order(:position).collect(&:convert_to_json!))
+    end
+  end
+
+  class Line < ApplicationRecord
+    extend Mobility
+    translates :content, fallbacks: true
+
+    def convert_to_json!
+      Parts::Line.new(content: content)
+    end
+  end
+
+  class Option < ApplicationRecord
+    def convert_to_json!
+      Parts::Option.new(content: content)
+    end
+
+    private
+
+    def content
+      I18n.t(['options', part.name, value].compact.join('.'))
+    end
+
+    def part
+      page_part || layout_part || structure_part
+    end
+  end
+
+  class Structure < ApplicationRecord
+    has_many :structure_items
+    has_one :page_part, as: :page_partable
+    has_one :layout_part, as: :layout_partable
+    has_one :part, as: :partable, class_name: 'Spina::Admin::Conferences::Part'
+
+    def convert_to_json!
+      Parts::Repeater.new(content: structure_items.order(:position)
+                                                  .collect(&:convert_to_json!)
+                                                  .each { |structure_item| structure_item.name = present_part.name })
+    end
+
+    def present_part
+      page_part || layout_part || part
+    end
+  end
+
+  class Text < ApplicationRecord
+    extend Mobility
+    translates :content, fallbacks: true
+
+    def convert_to_json!
+      Parts::Text.new(content: content)
+    end
+  end
+
+  class LayoutPart < ::Spina::ApplicationRecord
+    belongs_to :account
+    belongs_to :layout_partable, polymorphic: true
+
+    def convert_to_json!
+      raise <<~MESSAGE unless layout_partable.respond_to? :convert_to_json!
+        Cannot convert an instance of #{layout_partable_type} to JSON.
+        You need to modify #{__FILE__} and implement `convert_to_json!` for this partable.
+      MESSAGE
+
+      layout_partable.convert_to_json!.tap { |layout_partable| layout_partable.name = name }
+    end
+  end
+
+  class PagePart < ::Spina::ApplicationRecord
+    belongs_to :page
+    belongs_to :page_partable, polymorphic: true
+
+    def convert_to_json!
+      raise <<~MESSAGE unless page_partable.respond_to? :convert_to_json!
+        Cannot convert an instance of #{page_partable_type} to JSON.
+        You need to modify #{__FILE__} and implement `convert_to_json!` for this partable.
+      MESSAGE
+
+      page_partable.convert_to_json!.tap { |page_partable| page_partable.name = name }
+    end
+  end
+
+  class StructurePart < ::Spina::ApplicationRecord
+    belongs_to :structure_item
+    belongs_to :structure_partable, polymorphic: true
+
+    def convert_to_json!
+      raise <<~MESSAGE unless structure_partable.respond_to? :convert_to_json!
+        Cannot convert an instance of #{structure_partable_type} to JSON.
+        You need to modify #{__FILE__} and implement `convert_to_json!` for this partable.
+      MESSAGE
+
+      structure_partable.convert_to_json!.tap { |structure_partable| structure_partable.name = name }
+    end
+  end
+
+  class Page < Spina::ApplicationRecord
+    has_many :page_parts
+
+    def convert_page_parts_to_json!
+      page_parts.reject { |page_part| page_part.page_partable.nil? }
+                .collect(&:convert_to_json!)
+                .compact
+                .then { |parts| send(:"#{I18n.locale}_content").union(parts) }
+                .then { |parts| update("#{I18n.locale}_content": parts) }
+    end
+
+    def convert_json_to_parts!
+      update(page_parts: send(:"#{I18n.locale}_content").collect(&:convert_to_partable!)
+                                                        .compact
+                                                        .collect { |partable| PagePart.new(page_partable: partable) })
+    end
+  end
+
+  class Account < Spina::ApplicationRecord
+    has_many :layout_parts
+
+    def convert_layout_parts_to_json!
+      layout_parts.reject { |layout_part| layout_part.layout_partable.nil? }
+                  .collect(&:convert_to_json!)
+                  .compact
+                  .then { |parts| send(:"#{I18n.locale}_content").union(parts) }
+                  .then { |parts| update("#{I18n.locale}_content": parts) }
+    end
+
+    def convert_json_to_parts!
+      update(layout_parts: send(:"#{I18n.locale}_content")
+                             .collect(&:convert_to_partable!)
+                             .compact
+                             .collect { |partable| LayoutPart.new(layout_partable: partable) })
+    end
+  end
+
+  class StructureItem < Spina::ApplicationRecord
+    belongs_to :structure
+    has_many :structure_parts
+
+    def convert_to_json!
+      Parts::RepeaterContent.new(parts: structure_parts.reject { |structure_part| structure_part.structure_partable.nil? }
+                                                       .collect(&:convert_to_json!)
+                                                       .compact)
+    end
+  end
+
+  module Parts # :nodoc: all
+    class Attachment < Base
+      def convert_to_partable!
+        Spina::Attachment.find(attachment_id)
+      end
+    end
+
+    class Image < Base
+      def convert_to_partable!
+        Spina::Image.find(image_id)
+      end
+    end
+
+    class ImageCollection < Base
+      def convert_to_partable!
+        Spina::ImageCollection.new(images: images.collect(&:convert_to_partable!))
+      end
+    end
+
+    class Line < Base
+      def convert_to_partable!
+        Spina::Line.new(content: content)
+      end
+    end
+
+    class MultiLine < Base
+      def convert_to_partable!
+        Spina::Text.new(content: content)
+      end
+    end
+
+    class Text < Base
+      def convert_to_partable!
+        Spina::Text.new(content: content)
+      end
+    end
+
+    class Option < Base
+      def convert_to_partable!
+        Spina::Option.new(content: content)
+      end
+    end
+
+    class Repeater < Base
+      def convert_to_partable!
+        Spina::Structure.new(structure_items: content.collect(&:convert_to_structure_item!))
+      end
+    end
+
+    class RepeaterContent < Base
+      def convert_to_structure_item!
+        Spina::StructureItem.new(structure_parts: parts.collect(&:convert_to_partable!)
+                                                       .compact
+                                                       .collect { |partable| StructurePart.new(structure_partable: partable) })
+      end
+    end
+
+    module Admin
+      module Conferences
+        class Date < Spina::Parts::Base
+          def convert_to_partable!
+            Spina::Admin::Conferences::DatePart.new(content: content)
+          end
+        end
+
+        class EmailAddress < Spina::Parts::Base
+          def convert_to_partable!
+            Spina::Admin::Conferences::EmailAddressPart.new(content: content)
+          end
+        end
+
+        class Time < Spina::Parts::Base
+          def convert_to_partable!
+            Spina::Admin::Conferences::TimePart.new(content: content)
+          end
+        end
+
+        class Url < Spina::Parts::Base
+          def convert_to_partable!
+            Spina::Admin::Conferences::UrlPart.new(content: content)
+          end
+        end
+      end
+    end
+  end
+
+  module Admin
+    module Conferences
+      class DatePart < ApplicationRecord
+        def convert_to_json!
+          Spina::Parts::Admin::Conferences::Date.new(content: content)
+        end
+      end
+
+      class EmailAddressPart < ApplicationRecord
+        def convert_to_json!
+          Spina::Parts::Admin::Conferences::EmailAddress.new(content: content)
+        end
+      end
+
+      class TimePart < ApplicationRecord
+        def convert_to_json!
+          Spina::Parts::Admin::Conferences::Time.new(content: content)
+        end
+      end
+
+      class UrlPart < ApplicationRecord
+        def convert_to_json!
+          Spina::Parts::Admin::Conferences::Url.new(content: content)
+        end
+      end
+
+      class Part < ApplicationRecord
+        belongs_to :pageable, polymorphic: true
+        belongs_to :partable, polymorphic: true
+
+        def convert_to_json!
+          raise <<~MESSAGE unless partable.respond_to? :convert_to_json!
+            Cannot convert an instance of #{partable_type} to JSON.
+            You need to modify #{__FILE__} and implement `convert_to_json!` for this partable.
+          MESSAGE
+
+          partable.convert_to_json!.tap { |partable| partable.name = name }
+        end
+      end
+
+      module Pageable
+        extend ActiveSupport::Concern
+
+        included do
+          has_many :parts, as: :pageable
+
+          def convert_parts_to_json!
+            parts.reject { |part| part.partable.nil? }
+                 .collect(&:convert_to_json!)
+                 .compact
+                 .then { |parts| send(:"#{I18n.locale}_content").union(parts) }
+                 .then { |parts| update("#{I18n.locale}_content": parts) }
+          end
+
+          def convert_json_to_parts!
+            update(parts: send(:"#{I18n.locale}_content").collect(&:convert_to_partable!)
+                                                         .compact
+                                                         .collect { |partable| Part.new(partable: partable) })
+          end
+        end
+      end
+
+      class Conference < ApplicationRecord
+        include Pageable
+      end
+
+      class Presentation < ApplicationRecord
+        include Pageable
+      end
+    end
+  end
+end

data/db/migrate/20210417102513_add_locale_to_action_text_rich_texts.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class AddLocaleToActionTextRichTexts < ActiveRecord::Migration[6.1]
+  def change
+    add_column :action_text_rich_texts, :locale, :string
+    remove_index :action_text_rich_texts, column: %i[record_type record_id name], name: :index_action_text_rich_texts_uniqueness,
+                                          unique: true
+    add_index :action_text_rich_texts, %i[record_type record_id name locale], name: :index_action_text_rich_texts_uniqueness,
+                                                                              unique: true
+  end
+end

data/db/migrate/20210417102514_move_texts_to_action_text_rich_texts.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+class MoveTextsToActionTextRichTexts < ActiveRecord::Migration[6.1] # :nodoc:
+  def change
+    create_mobility_tables
+
+    Spina.config.locales.each do |locale|
+      I18n.with_locale(locale) do
+        move_presentation_abstracts
+        move_event_descriptions
+      end
+    end
+
+    remove_column :spina_conferences_presentation_translations, :abstract, :text
+    remove_column :spina_conferences_event_translations, :description, :text
+  end
+
+  private
+
+  def create_mobility_tables
+    create_table :mobility_text_translations do |t| # rubocop:disable Rails/CreateTableWithTimestamps
+      t.string :record
+    end
+    create_table :mobility_string_translations do |t| # rubocop:disable Rails/CreateTableWithTimestamps
+      t.string :record
+    end
+  end
+
+  def move_presentation_abstracts
+    reversible do |dir|
+      Spina::Admin::Conferences::Presentation.in_batches.each_record do |presentation|
+        dir.up { presentation.update(abstract: presentation.presentation_translation.abstract) }
+        dir.down do
+          break if presentation.abstract.blank?
+
+          presentation.presentation_translation.update(abstract: presentation.abstract.read_attribute_before_type_cast('body'))
+          presentation.abstract.destroy
+        end
+      end
+    end
+  end
+
+  def move_event_descriptions
+    reversible do |dir|
+      Spina::Admin::Conferences::Event.in_batches.each_record do |event|
+        dir.up { event.update(description: event.event_translation.description) }
+        dir.down do
+          break if event.description.blank?
+
+          event.event_translation.update(description: event.description.read_attribute_before_type_cast('body'))
+          event.description.destroy
+        end
+      end
+    end
+  end
+end
+
+module Spina
+  module Admin
+    module Conferences
+      class PresentationTranslation < ApplicationRecord
+        belongs_to :presentation, foreign_key: 'spina_conferences_presentation_id'
+      end
+
+      class EventTranslation < ApplicationRecord
+        belongs_to :event, foreign_key: 'spina_conferences_event_id'
+      end
+
+      class Presentation < ApplicationRecord
+        has_one :presentation_translation, -> { where locale: I18n.locale }, foreign_key: 'spina_conferences_presentation_id'
+
+        translates :abstract, backend: :action_text
+      end
+
+      class Event < ApplicationRecord
+        has_one :event_translation, -> { where locale: I18n.locale }, foreign_key: 'spina_conferences_event_id'
+
+        translates :description, backend: :action_text
+      end
+    end
+  end
+end

data/lib/spina/admin/conferences/engine.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Spina
+  module Admin
+    module Conferences
+      # Engine class for the plugin. This is where the plugin is registered as a {Spina::Plugin} with {Spina}.
+      # @note The +name+ and +namespace+ of the {Spina::Plugin} object is +'conferences'+ (for compatibility reasons).
+      class Engine < ::Rails::Engine
+        isolate_namespace Spina::Admin::Conferences
+
+        config.before_initialize do
+          ::Spina::Plugin.register do |plugin|
+            plugin.name = 'conferences'
+            plugin.namespace = 'conferences'
+          end
+        end
+
+        config.after_initialize do
+          Spina::Part.register(Spina::Parts::Admin::Conferences::Date)
+          Spina::Part.register(Spina::Parts::Admin::Conferences::EmailAddress)
+          Spina::Part.register(Spina::Parts::Admin::Conferences::Time)
+          Spina::Part.register(Spina::Parts::Admin::Conferences::Url)
+        end
+
+        config.to_prepare do
+          require 'mobility/action_text'
+        end
+      end
+    end
+  end
+end

data/lib/spina/admin/conferences/migration/renaming.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Spina
+  module Admin
+    module Conferences
+      module Migration
+        module Renaming
+          extend ActiveSupport::Concern
+
+          included do
+            @stale_migrations ||= []
+            @migrations_path ||= nil
+          end
+
+          class_methods do
+            def rename_migration(name, to:)
+              config.after_initialize do
+                migration = {}
+                migration[:old] = migration_hash(name)
+                migration[:new] = migration_hash(to)
+                @stale_migrations << migration if [migration[:old], migration[:new]].pluck(:file).all?(&:present?)
+              end
+            end
+
+            def raise_on_duplicate_migrations!
+              raise DuplicateMigrationsError, @stale_migrations if @stale_migrations.any?
+            end
+
+            private
+
+            attr_reader :duplicate_migrations
+
+            class DuplicateMigrationsError < ::StandardError
+              def initialize(migrations)
+                messages = migrations.collect { |migration| generate_message(migration) }
+                super(messages.join("\n"))
+              end
+
+              private
+
+              MIGRATION_REGEXP = /([0-9]+)_.+\.(spina(_admin)?_conferences).rb$/.freeze
+
+              def generate_message(migration)
+                old_version, old_scope = parse_filename(migration[:old][:file])
+                messages = []
+                messages << "#{File.basename(migration[:new][:file])} is a renamed version of #{File.basename(migration[:old][:file])}."
+                messages << "Rename #{File.basename(migration[:old][:file])} to #{old_version}_#{migration[:new][:name]}.#{old_scope}.rb " \
+                            "and delete #{File.basename(migration[:new][:file])}."
+                messages.join("\n")
+              end
+
+              def parse_filename(filename)
+                filename.scan(MIGRATION_REGEXP).first
+              end
+            end
+
+            def migration_hash(name)
+              { name: name, file: detect_migration(name) }
+            end
+
+            def migrations_path
+              @migrations_path || ActiveRecord::Tasks::DatabaseTasks.migrations_paths.first
+            end
+
+            def engine_migration_glob(name)
+              "#{migrations_path}/**/*_#{name}.spina{_admin,}_conferences_engine.rb"
+            end
+
+            def detect_migration(name)
+              Dir[engine_migration_glob(name)].first
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spina/admin/conferences/railtie.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spina/admin/conferences/migration/renaming'
+
+module Spina
+  module Admin
+    module Conferences
+      class Railtie < Rails::Railtie
+        include Migration::Renaming
+
+        rename_migration 'create_spina_conferences_dietary_requirement_name_translations_for_mobility_table_backend',
+                         to: 'create_spina_conferences_dietary_requirement_name_translations'
+        rename_migration 'create_spina_conferences_institution_name_and_city_translations_for_mobility_table_backend',
+                         to: 'create_spina_conferences_institution_name_and_city_translations'
+        rename_migration 'create_spina_conferences_presentation_attachment_type_name_translations_for_mobility_table_backend',
+                         to: 'create_spina_conferences_presentation_attachment_type_name_translations'
+        rename_migration 'create_spina_conferences_presentation_type_name_translations_for_mobility_table_backend',
+                         to: 'create_spina_conferences_presentation_type_name_translations'
+        rename_migration 'create_spina_conferences_room_building_and_number_translations_for_mobility_table_backend',
+                         to: 'create_spina_conferences_room_building_and_number_translations'
+        rename_migration 'create_spina_conferences_conference_name_translations_for_mobility_table_backend',
+                         to: 'create_spina_conferences_conference_name_translations'
+        rename_migration 'create_spina_conferences_session_name_translations_for_mobility_table_backend',
+                         to: 'create_spina_conferences_session_name_translations'
+        rename_migration 'create_spina_conferences_event_name_description_and_location_translations_for_mobility_table_backend',
+                         to: 'create_spina_conferences_event_name_description_and_location_translations'
+
+        config.after_initialize do
+          raise_on_duplicate_migrations!
+        end
+      end
+    end
+  end
+end