decidim-enhanced_textwork 1.0.0

data/app/commands/decidim/enhanced_textwork/admin/import_paragraphs.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic when an admin imports paragraphs from
+      # one component to another.
+      class ImportParagraphs < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(form)
+          @form = form
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) unless form.valid?
+
+          broadcast(:ok, import_paragraphs)
+        end
+
+        private
+
+        attr_reader :form
+
+        def import_paragraphs
+          paragraphs.map do |original_paragraph|
+            next if paragraph_already_copied?(original_paragraph, target_component)
+
+            Decidim::EnhancedTextwork::ParagraphBuilder.copy(
+              original_paragraph,
+              author: paragraph_author,
+              action_user: form.current_user,
+              extra_attributes: {
+                "component" => target_component
+              }.merge(paragraph_answer_attributes(original_paragraph))
+            )
+          end.compact
+        end
+
+        def paragraphs
+          @paragraphs = Decidim::EnhancedTextwork::Paragraph
+                       .where(component: origin_component)
+                       .where(state: paragraph_states)
+          @paragraphs = @paragraphs.where(scope: paragraph_scopes) unless paragraph_scopes.empty?
+          @paragraphs
+        end
+
+        def paragraph_states
+          @paragraph_states = @form.states
+
+          if @form.states.include?("not_answered")
+            @paragraph_states.delete("not_answered")
+            @paragraph_states.push(nil)
+          end
+
+          @paragraph_states
+        end
+
+        def paragraph_scopes
+          @form.scopes
+        end
+
+        def origin_component
+          @form.origin_component
+        end
+
+        def target_component
+          @form.current_component
+        end
+
+        def paragraph_already_copied?(original_paragraph, target_component)
+          original_paragraph.linked_resources(:paragraphs, "copied_from_component").any? do |paragraph|
+            paragraph.component == target_component
+          end
+        end
+
+        def paragraph_author
+          form.keep_authors ? nil : @form.current_organization
+        end
+
+        def paragraph_answer_attributes(original_paragraph)
+          return {} unless form.keep_answers
+
+          {
+            answer: original_paragraph.answer,
+            answered_at: original_paragraph.answered_at,
+            state: original_paragraph.state,
+            state_published_at: original_paragraph.state_published_at
+          }
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/import_participatory_text.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic when an admin imports paragraphs from
+      # a participatory text.
+      class ImportParticipatoryText < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(form)
+          @form = form
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) unless @form.valid?
+
+          transaction do
+            save_participatory_text_meta(@form)
+            parse_participatory_text_doc(@form)
+          end
+
+          broadcast(:ok)
+        rescue StandardError
+          broadcast(:invalid_file)
+        end
+
+        private
+
+        # Persist ParticipatoryText related meta information.
+        def save_participatory_text_meta(form)
+          document = ParticipatoryText.find_or_initialize_by(component: form.current_component)
+          document.update!(title: form.title, description: form.description)
+        end
+
+        def parse_participatory_text_doc(form)
+          return if form.document.blank?
+
+          document = form.document_text
+          document = Decidim::IoEncoder.to_standard_encoding(document)
+          markdown = DocToMarkdown.new(document, form.document_type).to_md
+          parser = MarkdownToParagraphs.new(form.current_component, form.current_user)
+          parser.parse(markdown)
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/merge_paragraphs.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic when an admin merges paragraphs from
+      # one component to another.
+      class MergeParagraphs < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(form)
+          @form = form
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) unless form.valid?
+
+          broadcast(:ok, merge_paragraphs)
+        end
+
+        private
+
+        attr_reader :form
+
+        def merge_paragraphs
+          transaction do
+            merged_paragraph = create_new_paragraph
+            merged_paragraph.link_resources(paragraphs_to_link, "copied_from_component")
+            form.paragraphs.each(&:destroy!) if form.same_component?
+            merged_paragraph
+          end
+        end
+
+        def paragraphs_to_link
+          return previous_links if form.same_component?
+
+          form.paragraphs
+        end
+
+        def previous_links
+          @previous_links ||= form.paragraphs.flat_map do |paragraph|
+            paragraph.linked_resources(:paragraphs, "copied_from_component")
+          end
+        end
+
+        def create_new_paragraph
+          original_paragraph = form.paragraphs.first
+
+          Decidim::EnhancedTextwork::ParagraphBuilder.copy(
+            original_paragraph,
+            author: form.current_organization,
+            action_user: form.current_user,
+            extra_attributes: {
+              component: form.target_component
+            },
+            skip_link: true
+          )
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/notify_paragraph_answer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command to notify about the change of the published state for a paragraph.
+      class NotifyParagraphAnswer < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # paragraph - The paragraph to write the answer for.
+        # initial_state - The paragraph state before the current process.
+        def initialize(paragraph, initial_state)
+          @paragraph = paragraph
+          @initial_state = initial_state.to_s
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :noop when the answer is not published or the state didn't changed.
+        # - :ok when everything is valid.
+        #
+        # Returns nothing.
+        def call
+          if paragraph.published_state? && state_changed?
+            transaction do
+              increment_score
+              notify_followers
+            end
+          end
+
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :paragraph, :initial_state
+
+        def state_changed?
+          initial_state != paragraph.state.to_s
+        end
+
+        def notify_followers
+          if paragraph.accepted?
+            publish_event(
+              "decidim.events.enhanced_textwork.paragraph_accepted",
+              Decidim::EnhancedTextwork::AcceptedParagraphEvent
+            )
+          elsif paragraph.rejected?
+            publish_event(
+              "decidim.events.enhanced_textwork.paragraph_rejected",
+              Decidim::EnhancedTextwork::RejectedParagraphEvent
+            )
+          elsif paragraph.evaluating?
+            publish_event(
+              "decidim.events.enhanced_textwork.paragraph_evaluating",
+              Decidim::EnhancedTextwork::EvaluatingParagraphEvent
+            )
+          end
+        end
+
+        def publish_event(event, event_class)
+          Decidim::EventsManager.publish(
+            event: event,
+            event_class: event_class,
+            resource: paragraph,
+            affected_users: paragraph.notifiable_identities,
+            followers: paragraph.followers - paragraph.notifiable_identities
+          )
+        end
+
+        def increment_score
+          if paragraph.accepted?
+            paragraph.coauthorships.find_each do |coauthorship|
+              Decidim::Gamification.increment_score(coauthorship.user_group || coauthorship.author, :accepted_paragraphs)
+            end
+          elsif initial_state == "accepted"
+            paragraph.coauthorships.find_each do |coauthorship|
+              Decidim::Gamification.decrement_score(coauthorship.user_group || coauthorship.author, :accepted_paragraphs)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/publish_answers.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic to publish many answers at once.
+      class PublishAnswers < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # component - The component that contains the answers.
+        # user - the Decidim::User that is publishing the answers.
+        # paragraph_ids - the identifiers of the paragraphs with the answers to be published.
+        def initialize(component, user, paragraph_ids)
+          @component = component
+          @user = user
+          @paragraph_ids = paragraph_ids
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if there are not paragraphs to publish.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) unless paragraphs.any?
+
+          paragraphs.each do |paragraph|
+            transaction do
+              mark_paragraph_as_answered(paragraph)
+              notify_paragraph_answer(paragraph)
+            end
+          end
+
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :component, :user, :paragraph_ids
+
+        def paragraphs
+          @paragraphs ||= Decidim::EnhancedTextwork::Paragraph
+                         .published
+                         .answered
+                         .state_not_published
+                         .where(component: component)
+                         .where(id: paragraph_ids)
+        end
+
+        def mark_paragraph_as_answered(paragraph)
+          Decidim.traceability.perform_action!(
+            "publish_answer",
+            paragraph,
+            user
+          ) do
+            paragraph.update!(state_published_at: Time.current)
+          end
+        end
+
+        def notify_paragraph_answer(paragraph)
+          NotifyParagraphAnswer.call(paragraph, nil)
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/publish_participatory_text.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic when an admin imports paragraphs from
+      # a participatory text.
+      class PublishParticipatoryText < UpdateParticipatoryText
+        # Public: Initializes the command.
+        #
+        # form - A PreviewParticipatoryTextForm form object with the params.
+        def initialize(form)
+          @form = form
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          transaction do
+            @failures = {}
+            update_contents_and_resort_paragraphs(form)
+            publish_drafts
+          end
+
+          if @failures.any?
+            broadcast(:invalid, @failures)
+          else
+            broadcast(:ok)
+          end
+        end
+
+        private
+
+        attr_reader :form
+
+        def publish_drafts
+          Decidim::EnhancedTextwork::Paragraph.where(component: form.current_component).drafts.find_each do |paragraph|
+            add_failure(paragraph) unless publish_paragraph(paragraph)
+          end
+          raise ActiveRecord::Rollback if @failures.any?
+        end
+
+        def add_failure(paragraph)
+          @failures[paragraph.id] = paragraph.errors.full_messages
+        end
+
+        # This will be the PaperTrail version shown in the version control feature (1 of 1).
+        # For an attribute to appear in the new version it has to be reset
+        # and reassigned, as PaperTrail only keeps track of object CHANGES.
+        def publish_paragraph(paragraph)
+          title, body = reset_paragraph_title_and_body(paragraph)
+
+          Decidim.traceability.perform_action!(:create, paragraph, form.current_user, visibility: "all") do
+            paragraph.update(title: title, body: body, published_at: Time.current)
+          end
+        end
+
+        # Reset the attributes to an empty string and return the old values.
+        def reset_paragraph_title_and_body(paragraph)
+          title = paragraph.title
+          body = paragraph.body
+
+          PaperTrail.request(enabled: false) do
+            # rubocop:disable Rails/SkipsModelValidations
+            paragraph.update_columns(
+              title: { I18n.locale => "" },
+              body: { I18n.locale => "" }
+            )
+            # rubocop:enable Rails/SkipsModelValidations
+          end
+
+          [title, body]
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/split_paragraphs.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic when an admin splits paragraphs from
+      # one component to another.
+      class SplitParagraphs < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(form)
+          @form = form
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) unless form.valid?
+
+          broadcast(:ok, split_paragraphs)
+        end
+
+        private
+
+        attr_reader :form
+
+        def split_paragraphs
+          transaction do
+            form.paragraphs.flat_map do |original_paragraph|
+              # If copying to the same component we only need one copy
+              # but linking to the original paragraph links, not the
+              # original paragraph.
+              create_paragraph(original_paragraph)
+              create_paragraph(original_paragraph) unless form.same_component?
+            end
+          end
+        end
+
+        def create_paragraph(original_paragraph)
+          split_paragraph = Decidim::EnhancedTextwork::ParagraphBuilder.copy(
+            original_paragraph,
+            author: form.current_organization,
+            action_user: form.current_user,
+            extra_attributes: {
+              component: form.target_component
+            },
+            skip_link: true
+          )
+
+          paragraphs_to_link = links_for(original_paragraph)
+          split_paragraph.link_resources(paragraphs_to_link, "copied_from_component")
+        end
+
+        def links_for(paragraph)
+          return paragraph unless form.same_component?
+
+          paragraph.linked_resources(:paragraphs, "copied_from_component")
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/unassign_paragraphs_from_valuator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic to unassign paragraphs from a given
+      # valuator.
+      class UnassignParagraphsFromValuator < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(form)
+          @form = form
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) unless form.valid?
+
+          unassign_paragraphs
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :form
+
+        def unassign_paragraphs
+          transaction do
+            form.paragraphs.flat_map do |paragraph|
+              assignment = find_assignment(paragraph)
+              unassign(assignment) if assignment
+            end
+          end
+        end
+
+        def find_assignment(paragraph)
+          Decidim::EnhancedTextwork::ValuationAssignment.find_by(
+            paragraph: paragraph,
+            valuator_role: form.valuator_role
+          )
+        end
+
+        def unassign(assignment)
+          Decidim.traceability.perform_action!(
+            :delete,
+            assignment,
+            form.current_user,
+            paragraph_title: assignment.paragraph.title
+          ) do
+            assignment.destroy!
+          end
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/update_paragraph.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic when a user updates a paragraph.
+      class UpdateParagraph < Rectify::Command
+        include ::Decidim::AttachmentMethods
+        include GalleryMethods
+        include HashtagsMethods
+
+        # Public: Initializes the command.
+        #
+        # form         - A form object with the params.
+        # paragraph - the paragraph to update.
+        def initialize(form, paragraph)
+          @form = form
+          @paragraph = paragraph
+          @attached_to = paragraph
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid, together with the paragraph.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if form.invalid?
+
+          delete_attachment(form.attachment) if delete_attachment?
+
+          if process_attachments?
+            @paragraph.attachments.destroy_all
+
+            build_attachment
+            return broadcast(:invalid) if attachment_invalid?
+          end
+
+          if process_gallery?
+            build_gallery
+            return broadcast(:invalid) if gallery_invalid?
+          end
+
+          transaction do
+            update_paragraph
+            update_paragraph_author
+            create_attachment if process_attachments?
+            create_gallery if process_gallery?
+            photo_cleanup!
+          end
+
+          broadcast(:ok, paragraph)
+        end
+
+        private
+
+        attr_reader :form, :paragraph, :attachment, :gallery
+
+        def update_paragraph
+          parsed_title = Decidim::ContentProcessor.parse_with_processor(:hashtag, form.title, current_organization: form.current_organization).rewrite
+          parsed_body = Decidim::ContentProcessor.parse_with_processor(:hashtag, form.body, current_organization: form.current_organization).rewrite
+          Decidim.traceability.update!(
+            paragraph,
+            form.current_user,
+            title: parsed_title,
+            body: parsed_body,
+            category: form.category,
+            scope: form.scope,
+            address: form.address,
+            latitude: form.latitude,
+            longitude: form.longitude,
+            created_in_meeting: form.created_in_meeting
+          )
+        end
+
+        def update_paragraph_author
+          paragraph.coauthorships.clear
+          paragraph.add_coauthor(form.author)
+          paragraph.save!
+          paragraph
+        end
+      end
+    end
+  end
+end