decidim-enhanced_textwork 1.0.0

data/db/migrate/20200203111239_add_paragraph_valuation_assignments.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddParagraphValuationAssignments < ActiveRecord::Migration[5.2]
+  def change
+    create_table :decidim_enhanced_textwork_valuation_assignments do |t|
+      t.references :decidim_paragraph, null: false, index: { name: "decidim_enhanced_textwork_valuation_assignment_paragraph" }
+      t.references :valuator_role, polymorphic: true, null: false, index: { name: "decidim_enhanced_textwork_valuation_assignment_valuator_role" }
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20200210135152_add_costs_to_paragraphs.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class AddCostsToParagraphs < ActiveRecord::Migration[5.2]
+  def change
+    add_column :decidim_enhanced_textwork_paragraphs, :cost, :decimal
+    add_column :decidim_enhanced_textwork_paragraphs, :cost_report, :jsonb
+    add_column :decidim_enhanced_textwork_paragraphs, :execution_period, :jsonb
+  end
+end

data/db/migrate/20200212120110_sync_paragraphs_state_with_amendments_state.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class SyncParagraphsStateWithAmendmentsState < ActiveRecord::Migration[5.2]
+  def up
+    execute <<-SQL.squish
+      UPDATE decidim_enhanced_textwork_paragraphs AS paragraphs
+      SET state = amendments.state
+      FROM decidim_amendments AS amendments
+      WHERE
+        paragraphs.state IS NULL AND
+        amendments.decidim_emendation_type = 'Decidim::EnhancedTextwork::Paragraph' AND
+        amendments.decidim_emendation_id = paragraphs.id AND
+        amendments.state IS NOT NULL
+    SQL
+  end
+
+  def down
+    execute <<-SQL.squish
+      UPDATE decidim_enhanced_textwork_paragraphs AS paragraphs
+      SET state = NULL
+      FROM decidim_amendments AS amendments
+      WHERE
+        amendments.decidim_emendation_type = 'Decidim::EnhancedTextwork::Paragraph' AND
+        amendments.decidim_emendation_id = paragraphs.id AND
+        amendments.state IS NOT NULL
+    SQL
+  end
+end

data/db/migrate/20200227175922_add_state_published_at_to_paragraphs.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddStatePublishedAtToParagraphs < ActiveRecord::Migration[5.2]
+  def change
+    add_column :decidim_enhanced_textwork_paragraphs, :state_published_at, :datetime
+  end
+end

data/db/migrate/20200306123652_publish_existing_paragraphs_state.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class PublishExistingParagraphsState < ActiveRecord::Migration[5.2]
+  def up
+    execute <<-SQL.squish
+      UPDATE decidim_enhanced_textwork_paragraphs SET state_published_at = COALESCE(answered_at, published_at) WHERE state IS NOT NULL
+    SQL
+  end
+
+  def down
+    execute <<-SQL.squish
+      UPDATE decidim_enhanced_textwork_paragraphs SET state_published_at = NULL
+    SQL
+  end
+end

data/db/migrate/20200708091228_move_paragraphs_fields_to_i18n.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+class MoveParagraphsFieldsToI18n < ActiveRecord::Migration[5.2]
+  def up
+    add_column :decidim_enhanced_textwork_paragraphs, :new_title, :jsonb
+    add_column :decidim_enhanced_textwork_paragraphs, :new_body, :jsonb
+
+    reset_column_information
+
+    PaperTrail.request(enabled: false) do
+      Decidim::EnhancedTextwork::Paragraph.find_each do |paragraph|
+        author = paragraph.coauthorships.first.author
+
+        locale = if author
+                   author.try(:locale).presence || author.try(:default_locale).presence || author.try(:organization).try(:default_locale).presence
+                 elsif paragraph.component && paragraph.component.participatory_space
+                   paragraph.component.participatory_space.organization.default_locale
+                 else
+                   I18n.default_locale.to_s
+                 end
+
+        paragraph.new_title = {
+          locale => paragraph.title
+        }
+        paragraph.new_body = {
+          locale => paragraph.body
+        }
+
+        paragraph.save(validate: false)
+      end
+    end
+
+    remove_indexs
+
+    remove_column :decidim_enhanced_textwork_paragraphs, :title
+    rename_column :decidim_enhanced_textwork_paragraphs, :new_title, :title
+    remove_column :decidim_enhanced_textwork_paragraphs, :body
+    rename_column :decidim_enhanced_textwork_paragraphs, :new_body, :body
+
+    create_indexs
+
+    reset_column_information
+  end
+
+  def down
+    add_column :decidim_enhanced_textwork_paragraphs, :new_title, :string
+    add_column :decidim_enhanced_textwork_paragraphs, :new_body, :string
+
+    reset_column_information
+
+    Decidim::EnhancedTextwork::Paragraph.find_each do |paragraph|
+      paragraph.new_title = paragraph.title.values.first
+      paragraph.new_body = paragraph.body.values.first
+
+      paragraph.save!
+    end
+
+    remove_indexs
+
+    remove_column :decidim_enhanced_textwork_paragraphs, :title
+    rename_column :decidim_enhanced_textwork_paragraphs, :new_title, :title
+    remove_column :decidim_enhanced_textwork_paragraphs, :body
+    rename_column :decidim_enhanced_textwork_paragraphs, :new_body, :body
+
+    create_indexs
+
+    reset_column_information
+  end
+
+  def reset_column_information
+    Decidim::User.reset_column_information
+    Decidim::Coauthorship.reset_column_information
+    Decidim::EnhancedTextwork::Paragraph.reset_column_information
+    Decidim::Organization.reset_column_information
+  end
+
+  def remove_indexs
+    remove_index :decidim_enhanced_textwork_paragraphs, name: "decidim_enhanced_textwork_paragraph_title_search"
+    remove_index :decidim_enhanced_textwork_paragraphs, name: "decidim_enhanced_textwork_paragraph_body_search"
+  end
+
+  def create_indexs
+    execute "CREATE INDEX decidim_enhanced_textwork_paragraph_title_search ON decidim_enhanced_textwork_paragraphs(md5(title::text))"
+    execute "CREATE INDEX decidim_enhanced_textwork_paragraph_body_search ON decidim_enhanced_textwork_paragraphs(md5(body::text))"
+  end
+end

data/db/migrate/20200730131631_move_paragraph_endorsed_event_notifications_to_resource_endorsed_event.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class MoveParagraphEndorsedEventNotificationsToResourceEndorsedEvent < ActiveRecord::Migration[5.2]
+  def up
+    Decidim::Notification.where(event_name: "decidim.events.enhanced_textwork.paragraph_endorsed", event_class: "Decidim::EnhancedTextwork::ParagraphEndorsedEvent").find_each do |notification|
+      notification.update(event_name: "decidim.events.resource_endorsed", event_class: "Decidim::ResourceEndorsedEvent")
+    end
+  end
+
+  def down
+    Decidim::Notification.where(
+      event_name: "decidim.events.resource_endorsed",
+      event_class: "Decidim::ResourceEndorsedEvent",
+      decidim_resource_type: "Decidim::EnhancedTextwork::Paragraph"
+    )
+                         .find_each do |notification|
+      notification.update(event_name: "decidim.events.enhanced_textwork.paragraph_endorsed", event_class: "Decidim::EnhancedTextwork::ParagraphEndorsedEvent")
+    end
+  end
+end

data/db/migrate/20200827154156_add_commentable_counter_cache_to_paragraphs.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddCommentableCounterCacheToParagraphs < ActiveRecord::Migration[5.2]
+  def change
+    add_column :decidim_enhanced_textwork_paragraphs, :comments_count, :integer, null: false, default: 0, index: true
+    add_column :decidim_enhanced_textwork_collaborative_drafts, :comments_count, :integer, null: false, default: 0, index: true
+    Decidim::EnhancedTextwork::Paragraph.reset_column_information
+    Decidim::EnhancedTextwork::Paragraph.find_each(&:update_comments_count)
+    Decidim::EnhancedTextwork::CollaborativeDraft.reset_column_information
+    Decidim::EnhancedTextwork::CollaborativeDraft.find_each(&:update_comments_count)
+  end
+end

data/db/migrate/20201002085508_fix_paragraphs_data.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class FixParagraphsData < ActiveRecord::Migration[5.2]
+  def up
+    reset_column_information
+
+    PaperTrail.request(enabled: false) do
+      Decidim::EnhancedTextwork::Paragraph.find_each do |paragraph|
+        next if paragraph.title.is_a?(Hash) && paragraph.body.is_a?(Hash)
+
+        author = paragraph.coauthorships.first.author
+
+        locale = author.try(:locale).presence || author.try(:default_locale).presence || author.try(:organization).try(:default_locale).presence
+
+        # rubocop:disable Rails/SkipsModelValidations
+        values = {}
+        values[:title] = { locale => paragraph.title } unless paragraph.title.is_a?(Hash)
+        values[:body] = { locale => paragraph.body } unless paragraph.body.is_a?(Hash)
+
+        paragraph.update_columns(values)
+        # rubocop:enable Rails/SkipsModelValidations
+      end
+    end
+
+    reset_column_information
+  end
+
+  def down; end
+
+  def reset_column_information
+    Decidim::User.reset_column_information
+    Decidim::Coauthorship.reset_column_information
+    Decidim::EnhancedTextwork::Paragraph.reset_column_information
+    Decidim::Organization.reset_column_information
+  end
+end

data/db/migrate/20210127115628_fix_answered_paragraphs_after_copy.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class FixAnsweredParagraphsAfterCopy < ActiveRecord::Migration[5.2]
+  def change
+    paragraphs_after_copy = Decidim::ResourceLink.where(from_type: "Decidim::EnhancedTextwork::Paragraph").pluck(:from_id)
+
+    result = Decidim::EnhancedTextwork::Paragraph.where.not(state_published_at: nil).where(state: nil, id: paragraphs_after_copy)
+
+    result.find_each do |paragraph|
+      paragraph.state_published_at = nil
+      paragraph.save!
+    end
+  end
+end

data/db/migrate/20210310102839_add_followable_counter_cache_to_paragraphs.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class AddFollowableCounterCacheToParagraphs < ActiveRecord::Migration[5.2]
+  def change
+    add_column :decidim_enhanced_textwork_paragraphs, :follows_count, :integer, null: false, default: 0, index: true
+
+    reversible do |dir|
+      dir.up do
+        Decidim::EnhancedTextwork::Paragraph.reset_column_information
+        Decidim::EnhancedTextwork::Paragraph.find_each do |record|
+          record.class.reset_counters(record.id, :follows)
+        end
+      end
+    end
+  end
+end

data/db/migrate/20210310120812_add_enhanced_textwork_followable_counter_cache_to_collaborative_drafts.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class AddEnhancedTextworkFollowableCounterCacheToCollaborativeDrafts < ActiveRecord::Migration[5.2]
+  def change
+    add_column :decidim_enhanced_textwork_collaborative_drafts, :follows_count, :integer, null: false, default: 0, index: true
+
+    reversible do |dir|
+      dir.up do
+        Decidim::EnhancedTextwork::CollaborativeDraft.reset_column_information
+        Decidim::EnhancedTextwork::CollaborativeDraft.find_each do |record|
+          record.class.reset_counters(record.id, :follows)
+        end
+      end
+    end
+  end
+end

data/db/migrate/20210318082934_fix_counters_for_copied_paragraphs.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class FixCountersForCopiedParagraphs < ActiveRecord::Migration[5.2]
+  def up
+    copies_ids = Decidim::ResourceLink
+                 .where(
+                   name: "copied_from_component",
+                   from_type: "Decidim::EnhancedTextwork::Paragraph",
+                   to_type: "Decidim::EnhancedTextwork::Paragraph"
+                 ).pluck(:to_id)
+
+    Decidim::EnhancedTextwork::Paragraph.where(id: copies_ids).find_each do |record|
+      record.class.reset_counters(record.id, :follows)
+      record.update_comments_count
+    end
+  end
+
+  def down; end
+end

data/lib/decidim/api/paragraph_input_filter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    class ParagraphInputFilter < Decidim::Core::BaseInputFilter
+      include Decidim::Core::HasPublishableInputFilter
+
+      graphql_name "ParagraphFilter"
+      description "A type used for filtering paragraphs inside a participatory space.
+
+A typical query would look like:
+
+```
+  {
+    participatoryProcesses {
+      components {
+        ...on Paragraphs {
+          paragraphs(filter:{ publishedBefore: \"2020-01-01\" }) {
+            id
+          }
+        }
+      }
+    }
+  }
+```
+"
+    end
+  end
+end

data/lib/decidim/api/paragraph_input_sort.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    class ParagraphInputSort < Decidim::Core::BaseInputSort
+      include Decidim::Core::HasPublishableInputSort
+      include Decidim::Core::HasEndorsableInputSort
+
+      graphql_name "ParagraphSort"
+      description "A type used for sorting paragraphs"
+
+      argument :id, GraphQL::Types::String, "Sort by ID, valid values are ASC or DESC", required: false
+      argument :vote_count,
+               type: GraphQL::Types::String,
+               description: "Sort by number of votes, valid values are ASC or DESC. Will be ignored if votes are hidden",
+               required: false,
+               as: :paragraph_votes_count
+    end
+  end
+end

data/lib/decidim/api/paragraph_type.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    class ParagraphType < Decidim::Api::Types::BaseObject
+      description "A paragraph"
+
+      implements Decidim::Comments::CommentableInterface
+      implements Decidim::Core::CoauthorableInterface
+      implements Decidim::Core::CategorizableInterface
+      implements Decidim::Core::ScopableInterface
+      implements Decidim::Core::AttachableInterface
+      implements Decidim::Core::FingerprintInterface
+      implements Decidim::Core::AmendableInterface
+      implements Decidim::Core::AmendableEntityInterface
+      implements Decidim::Core::TraceableInterface
+      implements Decidim::Core::EndorsableInterface
+      implements Decidim::Core::TimestampsInterface
+
+      field :id, GraphQL::Types::ID, null: false
+      field :title, Decidim::Core::TranslatedFieldType, "The title for this title", null: true
+      field :body, Decidim::Core::TranslatedFieldType, "The description for this body", null: true
+      field :address, GraphQL::Types::String, "The physical address (location) of this paragraph", null: true
+      field :coordinates, Decidim::Core::CoordinatesType, "Physical coordinates for this paragraph", null: true
+
+      def coordinates
+        [object.latitude, object.longitude]
+      end
+      field :reference, GraphQL::Types::String, "This paragraph's unique reference", null: true
+      field :state, GraphQL::Types::String, "The answer status in which paragraph is in", null: true
+      field :answer, Decidim::Core::TranslatedFieldType, "The answer feedback for the status for this paragraph", null: true
+
+      field :answered_at, Decidim::Core::DateTimeType, description: "The date and time this paragraph was answered", null: true
+
+      field :published_at, Decidim::Core::DateTimeType, description: "The date and time this paragraph was published", null: true
+
+      field :participatory_text_level, GraphQL::Types::String, description: "If it is a participatory text, the level indicates the type of paragraph", null: true
+      field :position, GraphQL::Types::Int, "Position of this paragraph in the participatory text", null: true
+
+      field :official, GraphQL::Types::Boolean, "Whether this paragraph is official or not", method: :official?, null: true
+      field :created_in_meeting, GraphQL::Types::Boolean, "Whether this paragraph comes from a meeting or not", method: :official_meeting?, null: true
+      field :meeting, Decidim::Meetings::MeetingType, description: "If the paragraph comes from a meeting, the related meeting", null: true
+
+      def meeting
+        object.authors.first if object.official_meeting?
+      end
+
+      field :vote_count, GraphQL::Types::Int, description: "The total amount of votes the paragraph has received", null: true
+
+      def vote_count
+        current_component = object.component
+        object.paragraph_votes_count unless current_component.current_settings.votes_hidden?
+      end
+    end
+  end
+end

data/lib/decidim/api/paragraphs_type.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    class ParagraphListHelper < Decidim::Core::ComponentListBase
+      # only querying published posts
+      def query_scope
+        super.published
+      end
+    end
+
+    class ParagraphFinderHelper < Decidim::Core::ComponentFinderBase
+      # only querying published posts
+      def query_scope
+        super.published
+      end
+    end
+
+    class ParagraphsType < Decidim::Api::Types::BaseObject
+      implements Decidim::Core::ComponentInterface
+
+      graphql_name "Paragraphs"
+      description "A paragraphs component of a participatory space."
+
+      field :paragraphs, type: Decidim::EnhancedTextwork::ParagraphType.connection_type, description: "List all paragraphs", connection: true, null: true do
+        argument :order, Decidim::EnhancedTextwork::ParagraphInputSort, "Provides several methods to order the results", required: false
+        argument :filter, Decidim::EnhancedTextwork::ParagraphInputFilter, "Provides several methods to filter the results", required: false
+      end
+
+      field :paragraph, type: Decidim::EnhancedTextwork::ParagraphType, description: "Finds one paragraph", null: true do
+        argument :id, GraphQL::Types::ID, "The ID of the paragraph", required: true
+      end
+
+      def paragraphs(filter: {}, order: {})
+        Decidim::EnhancedTextwork::ParagraphListHelper.new(model_class: Paragraph).call(object, { filter: filter, order: order }, context)
+      end
+
+      def paragraph(id:)
+        Decidim::EnhancedTextwork::ParagraphFinderHelper.new(model_class: Paragraph).call(object, { id: id }, context)
+      end
+    end
+  end
+end

data/lib/decidim/content_parsers/paragraph_parser.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ContentParsers
+    # A parser that searches mentions of Paragraphs in content.
+    #
+    # This parser accepts two ways for linking Paragraphs.
+    # - Using a standard url starting with http or https.
+    # - With a word starting with `~` and digits afterwards will be considered a possible mentioned paragraph.
+    # For example `~1234`, but no `~ 1234`.
+    #
+    # Also fills a `Metadata#linked_paragraphs` attribute.
+    #
+    # @see BaseParser Examples of how to use a content parser
+    class ParagraphParser < BaseParser
+      # Class used as a container for metadata
+      #
+      # @!attribute linked_paragraphs
+      #   @return [Array] an array of Decidim::EnhancedTextwork::Paragraph mentioned in content
+      Metadata = Struct.new(:linked_paragraphs)
+
+      # Matches a URL
+      URL_REGEX_SCHEME = '(?:http(s)?:\/\/)'
+      URL_REGEX_CONTENT = '[\w.-]+[\w\-\._~:\/?#\[\]@!\$&\'\(\)\*\+,;=.]+'
+      URL_REGEX_END_CHAR = '[\d]'
+      URL_REGEX = %r{#{URL_REGEX_SCHEME}#{URL_REGEX_CONTENT}/paragraphs/#{URL_REGEX_END_CHAR}+}i.freeze
+      # Matches a mentioned Paragraph ID (~(d)+ expression)
+      ID_REGEX = /~(\d+)/.freeze
+
+      def initialize(content, context)
+        super
+        @metadata = Metadata.new([])
+      end
+
+      # Replaces found mentions matching an existing
+      # Paragraph with a global id for that Paragraph. Other mentions found that doesn't
+      # match an existing Paragraph are returned as they are.
+      #
+      # @return [String] the content with the valid mentions replaced by a global id.
+      def rewrite
+        rewrited_content = parse_for_urls(content)
+        parse_for_ids(rewrited_content)
+      end
+
+      # (see BaseParser#metadata)
+      attr_reader :metadata
+
+      private
+
+      def parse_for_urls(content)
+        content.gsub(URL_REGEX) do |match|
+          paragraph = paragraph_from_url_match(match)
+          if paragraph
+            @metadata.linked_paragraphs << paragraph.id
+            paragraph.to_global_id
+          else
+            match
+          end
+        end
+      end
+
+      def parse_for_ids(content)
+        content.gsub(ID_REGEX) do |match|
+          paragraph = paragraph_from_id_match(Regexp.last_match(1))
+          if paragraph
+            @metadata.linked_paragraphs << paragraph.id
+            paragraph.to_global_id
+          else
+            match
+          end
+        end
+      end
+
+      def paragraph_from_url_match(match)
+        uri = URI.parse(match)
+        return if uri.path.blank?
+
+        paragraph_id = uri.path.split("/").last
+        find_paragraph_by_id(paragraph_id)
+      rescue URI::InvalidURIError
+        Rails.logger.error("#{e.message}=>#{e.backtrace}")
+        nil
+      end
+
+      def paragraph_from_id_match(match)
+        paragraph_id = match
+        find_paragraph_by_id(paragraph_id)
+      end
+
+      def find_paragraph_by_id(id)
+        if id.present?
+          spaces = Decidim.participatory_space_manifests.flat_map do |manifest|
+            manifest.participatory_spaces.call(context[:current_organization]).public_spaces
+          end
+          components = Component.where(participatory_space: spaces).published
+          Decidim::EnhancedTextwork::Paragraph.where(component: components).find_by(id: id)
+        end
+      end
+    end
+  end
+end

data/lib/decidim/content_renderers/paragraph_renderer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ContentRenderers
+    # A renderer that searches Global IDs representing paragraphs in content
+    # and replaces it with a link to their show page.
+    #
+    # e.g. gid://<APP_NAME>/Decidim::EnhancedTextwork::Paragraph/1
+    #
+    # @see BaseRenderer Examples of how to use a content renderer
+    class ParagraphRenderer < BaseRenderer
+      # Matches a global id representing a Decidim::User
+      GLOBAL_ID_REGEX = %r{gid://([\w-]*/Decidim::EnhancedTextwork::Paragraph/(\d+))}i.freeze
+
+      # Replaces found Global IDs matching an existing paragraph with
+      # a link to its show page. The Global IDs representing an
+      # invalid Decidim::EnhancedTextwork::Paragraph are replaced with '???' string.
+      #
+      # @return [String] the content ready to display (contains HTML)
+      def render(_options = nil)
+        return content unless content.respond_to?(:gsub)
+
+        content.gsub(GLOBAL_ID_REGEX) do |paragraph_gid|
+          paragraph = GlobalID::Locator.locate(paragraph_gid)
+          Decidim::EnhancedTextwork::ParagraphPresenter.new(paragraph).display_mention
+        rescue ActiveRecord::RecordNotFound
+          paragraph_id = paragraph_gid.split("/").last
+          "~#{paragraph_id}"
+        end
+      end
+    end
+  end
+end

data/lib/decidim/enhanced_textwork/admin.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # This module contains all the domain logic associated to Decidim's Paragraph
+    # component admin panel.
+    module Admin
+    end
+  end
+end

data/lib/decidim/enhanced_textwork/admin_engine.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # This is the engine that runs on the public interface of `decidim-paragraphs`.
+    class AdminEngine < ::Rails::Engine
+      isolate_namespace Decidim::EnhancedTextwork::Admin
+
+      paths["db/migrate"] = nil
+      paths["lib/tasks"] = nil
+
+      routes do
+        resources :paragraphs, only: [:show, :index, :new, :create, :edit, :update] do
+          resources :valuation_assignments, only: [:destroy]
+          collection do
+            post :update_category
+            post :publish_answers
+            post :update_scope
+            resource :paragraphs_import, only: [:new, :create]
+            resource :paragraphs_merge, only: [:create]
+            resource :paragraphs_split, only: [:create]
+            resource :valuation_assignment, only: [:create, :destroy]
+          end
+          member do
+            delete :destroy_draft
+          end
+          resources :paragraph_answers, only: [:edit, :update]
+          resources :paragraph_notes, only: [:create]
+        end
+
+        resources :participatory_texts, only: [:index] do
+          collection do
+            get :new_editor
+            get :new_import
+            post :import
+            patch :import
+            post :import_from_editor
+            patch :import_from_editor
+            post :update
+            post :discard
+          end
+        end
+
+        root to: "paragraphs#index"
+      end
+
+      def load_seed
+        nil
+      end
+    end
+  end
+end

data/lib/decidim/enhanced_textwork/api.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    autoload :ParagraphInputFilter, "decidim/api/paragraph_input_filter"
+    autoload :ParagraphInputSort, "decidim/api/paragraph_input_sort"
+    autoload :ParagraphType, "decidim/api/paragraph_type"
+    autoload :ParagraphsType, "decidim/api/paragraphs_type"
+  end
+end