decidim-enhanced_textwork 1.0.0

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      #  A command with all the business logic when an admin batch updates paragraphs category.
+      class UpdateParagraphCategory < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # category_id - the category id to update
+        # paragraph_ids - the paragraphs ids to update.
+        def initialize(category_id, paragraph_ids)
+          @category = Decidim::Category.find_by id: category_id
+          @paragraph_ids = paragraph_ids
+          @response = { category_name: "", successful: [], errored: [] }
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :update_paragraphs_category - when everything is ok, returns @response.
+        # - :invalid_category - if the category is blank.
+        # - :invalid_paragraph_ids - if the paragraph_ids is blank.
+        #
+        # Returns @response hash:
+        #
+        # - :category_name - the translated_name of the category assigned
+        # - :successful - Array of names of the updated paragraphs
+        # - :errored - Array of names of the paragraphs not updated because they already had the category assigned
+        def call
+          return broadcast(:invalid_category) if @category.blank?
+          return broadcast(:invalid_paragraph_ids) if @paragraph_ids.blank?
+
+          @response[:category_name] = @category.translated_name
+          Paragraph.where(id: @paragraph_ids).find_each do |paragraph|
+            if @category == paragraph.category
+              @response[:errored] << paragraph.title
+            else
+              transaction do
+                update_paragraph_category paragraph
+                notify_author paragraph if paragraph.coauthorships.any?
+              end
+              @response[:successful] << paragraph.title
+            end
+          end
+
+          broadcast(:update_paragraphs_category, @response)
+        end
+
+        private
+
+        def update_paragraph_category(paragraph)
+          paragraph.update!(
+            category: @category
+          )
+        end
+
+        def notify_author(paragraph)
+          Decidim::EventsManager.publish(
+            event: "decidim.events.enhanced_textwork.paragraph_update_category",
+            event_class: Decidim::EnhancedTextwork::Admin::UpdateParagraphCategoryEvent,
+            resource: paragraph,
+            affected_users: paragraph.notifiable_identities
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      #  A command with all the business logic when an admin batch updates paragraphs scope.
+      class UpdateParagraphScope < Rectify::Command
+        include TranslatableAttributes
+        # Public: Initializes the command.
+        #
+        # scope_id - the scope id to update
+        # paragraph_ids - the paragraphs ids to update.
+        def initialize(scope_id, paragraph_ids)
+          @scope = Decidim::Scope.find_by id: scope_id
+          @paragraph_ids = paragraph_ids
+          @response = { scope_name: "", successful: [], errored: [] }
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :update_paragraphs_scope - when everything is ok, returns @response.
+        # - :invalid_scope - if the scope is blank.
+        # - :invalid_paragraph_ids - if the paragraph_ids is blank.
+        #
+        # Returns @response hash:
+        #
+        # - :scope_name - the translated_name of the scope assigned
+        # - :successful - Array of names of the updated paragraphs
+        # - :errored - Array of names of the paragraphs not updated because they already had the scope assigned
+        def call
+          return broadcast(:invalid_scope) if @scope.blank?
+          return broadcast(:invalid_paragraph_ids) if @paragraph_ids.blank?
+
+          update_paragraphs_scope
+
+          broadcast(:update_paragraphs_scope, @response)
+        end
+
+        private
+
+        attr_reader :scope, :paragraph_ids
+
+        def update_paragraphs_scope
+          @response[:scope_name] = translated_attribute(scope.name, scope.organization)
+          Paragraph.where(id: paragraph_ids).find_each do |paragraph|
+            if scope == paragraph.scope
+              @response[:errored] << paragraph.title
+            else
+              transaction do
+                update_paragraph_scope paragraph
+                notify_author paragraph if paragraph.coauthorships.any?
+              end
+              @response[:successful] << paragraph.title
+            end
+          end
+        end
+
+        def update_paragraph_scope(paragraph)
+          paragraph.update!(
+            scope: scope
+          )
+        end
+
+        def notify_author(paragraph)
+          Decidim::EventsManager.publish(
+            event: "decidim.events.enhanced_textwork.paragraph_update_scope",
+            event_class: Decidim::EnhancedTextwork::Admin::UpdateParagraphScopeEvent,
+            resource: paragraph,
+            affected_users: paragraph.notifiable_identities
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic when an admin updates participatory text paragraphs.
+      class UpdateParticipatoryText < Rectify::Command
+        include Decidim::TranslatableAttributes
+
+        # 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)
+          end
+
+          if @failures.any?
+            broadcast(:invalid, @failures)
+          else
+            broadcast(:ok)
+          end
+        end
+
+        private
+
+        attr_reader :form
+
+        # Prevents PaperTrail from creating versions while updating participatory text paragraphs.
+        # A first version will be created when publishing the Participatory Text.
+        def update_contents_and_resort_paragraphs(form)
+          PaperTrail.request(enabled: false) do
+            form.paragraphs.each do |prop_form|
+              add_failure(prop_form) if prop_form.invalid?
+
+              paragraph = Paragraph.where(component: form.current_component).find(prop_form.id)
+              paragraph.set_list_position(prop_form.position) if paragraph.position != prop_form.position
+              paragraph.title = { I18n.locale => translated_attribute(prop_form.title) }
+              paragraph.body = if paragraph.participatory_text_level == ParticipatoryTextSection::LEVELS[:article]
+                                { I18n.locale => translated_attribute(prop_form.body) }
+                              else
+                                { I18n.locale => "" }
+                              end
+
+              add_failure(paragraph) unless paragraph.save
+            end
+          end
+          raise ActiveRecord::Rollback if @failures.any?
+        end
+
+        def add_failure(paragraph)
+          @failures[paragraph.id] = paragraph.errors.full_messages
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/create_collaborative_draft.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic when a user creates a new collaborative draft.
+    class CreateCollaborativeDraft < Rectify::Command
+      include ::Decidim::AttachmentMethods
+      include HashtagsMethods
+
+      # Public: Initializes the command.
+      #
+      # form         - A form object with the params.
+      # current_user - The current user.
+      def initialize(form, current_user)
+        @form = form
+        @current_user = current_user
+        @attached_to = nil
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the collaborative draft.
+      # - :invalid if the form wasn't valid and we couldn't proceed.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) if form.invalid?
+
+        if process_attachments?
+          build_attachment
+          return broadcast(:invalid) if attachment_invalid?
+        end
+
+        transaction do
+          create_collaborative_draft
+          create_attachment if process_attachments?
+        end
+
+        broadcast(:ok, collaborative_draft)
+      end
+
+      private
+
+      attr_reader :form, :collaborative_draft, :attachment
+
+      def create_collaborative_draft
+        @collaborative_draft = Decidim.traceability.perform_action!(
+          :create,
+          CollaborativeDraft,
+          @form.current_user,
+          visibility: "public-only"
+        ) do
+          draft = CollaborativeDraft.new(
+            title: title_with_hashtags,
+            body: body_with_hashtags,
+            category: form.category,
+            scope: form.scope,
+            component: form.component,
+            address: form.address,
+            latitude: form.latitude,
+            longitude: form.longitude,
+            state: "open"
+          )
+          draft.coauthorships.build(author: @current_user, user_group: @form.user_group)
+          draft.save!
+          draft
+        end
+
+        @attached_to = @collaborative_draft
+      end
+
+      def user_group
+        @user_group ||= Decidim::UserGroup.find_by(organization: organization, id: form.user_group_id)
+      end
+
+      def organization
+        @organization ||= @current_user.organization
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/create_paragraph.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic when a user creates a new paragraph.
+    class CreateParagraph < Rectify::Command
+      include ::Decidim::AttachmentMethods
+      include HashtagsMethods
+
+      # Public: Initializes the command.
+      #
+      # form         - A form object with the params.
+      # current_user - The current user.
+      # coauthorships - The coauthorships of the paragraph.
+      def initialize(form, current_user, coauthorships = nil)
+        @form = form
+        @current_user = current_user
+        @coauthorships = coauthorships
+      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?
+
+        if paragraph_limit_reached?
+          form.errors.add(:base, I18n.t("decidim.enhanced_textwork.new.limit_reached"))
+          return broadcast(:invalid)
+        end
+
+        transaction do
+          create_paragraph
+        end
+
+        broadcast(:ok, paragraph)
+      end
+
+      private
+
+      attr_reader :form, :paragraph, :attachment
+
+      # Prevent PaperTrail from creating an additional version
+      # in the paragraph multi-step creation process (step 1: create)
+      #
+      # A first version will be created in step 4: publish
+      # for diff rendering in the paragraph version control
+      def create_paragraph
+        PaperTrail.request(enabled: false) do
+          @paragraph = Decidim.traceability.perform_action!(
+            :create,
+            Decidim::EnhancedTextwork::Paragraph,
+            @current_user,
+            visibility: "public-only"
+          ) do
+            paragraph = Paragraph.new(
+              title: {
+                I18n.locale => title_with_hashtags
+              },
+              body: {
+                I18n.locale => body_with_hashtags
+              },
+              component: form.component
+            )
+            paragraph.add_coauthor(@current_user, user_group: user_group)
+            paragraph.save!
+            paragraph
+          end
+        end
+      end
+
+      def paragraph_limit_reached?
+        return false if @coauthorships.present?
+
+        paragraph_limit = form.current_component.settings.paragraph_limit
+
+        return false if paragraph_limit.zero?
+
+        if user_group
+          user_group_paragraphs.count >= paragraph_limit
+        else
+          current_user_paragraphs.count >= paragraph_limit
+        end
+      end
+
+      def user_group
+        @user_group ||= Decidim::UserGroup.find_by(organization: organization, id: form.user_group_id)
+      end
+
+      def organization
+        @organization ||= @current_user.organization
+      end
+
+      def current_user_paragraphs
+        Paragraph.from_author(@current_user).where(component: form.current_component).except_withdrawn
+      end
+
+      def user_group_paragraphs
+        Paragraph.from_user_group(@user_group).where(component: form.current_component).except_withdrawn
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/destroy_paragraph.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic when a user destroys a draft paragraph.
+    class DestroyParagraph < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # paragraph     - The paragraph to destroy.
+      # current_user - The current user.
+      def initialize(paragraph, current_user)
+        @paragraph = paragraph
+        @current_user = current_user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid and the paragraph is deleted.
+      # - :invalid if the paragraph is not a draft.
+      # - :invalid if the paragraph's author is not the current user.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless @paragraph.draft?
+        return broadcast(:invalid) unless @paragraph.authored_by?(@current_user)
+
+        @paragraph.destroy!
+
+        broadcast(:ok, @paragraph)
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/gallery_methods.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A module with all the gallery common methods for paragraphs
+    # and collaborative draft commands.
+    # Allows to create several image attachments at once
+    module GalleryMethods
+      include ::Decidim::GalleryMethods
+
+      private
+
+      def gallery_allowed?
+        @form.current_component.settings.attachments_allowed?
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/hashtags_methods.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A module with all the hash tags common methods for paragraphs
+    # and collaborative draft commands.
+    module HashtagsMethods
+      private
+
+      def title_with_hashtags
+        @title_with_hashtags ||= Decidim::ContentProcessor.parse_with_processor(:hashtag, form.title, current_organization: form.current_organization).rewrite
+      end
+
+      def body_with_hashtags
+        @body_with_hashtags ||= begin
+          ret = Decidim::ContentProcessor.parse_with_processor(:hashtag, form.body, current_organization: form.current_organization).rewrite.strip
+          ret += "\n#{body_extra_hashtags.strip}" unless body_extra_hashtags.empty?
+          ret
+        end
+      end
+
+      def body_extra_hashtags
+        @body_extra_hashtags ||= if form.respond_to?(:extra_hashtags)
+                                   Decidim::ContentProcessor.parse_with_processor(
+                                     :hashtag,
+                                     form.extra_hashtags.map { |hashtag| "##{hashtag}" }.join(" "),
+                                     current_organization: form.current_organization,
+                                     extra_hashtags: true
+                                   ).rewrite
+                                 else
+                                   ""
+                                 end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/publish_collaborative_draft.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic when a user publishes a collaborative_draft.
+    class PublishCollaborativeDraft < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # collaborative_draft - The collaborative_draft to publish.
+      # current_user - The current user.
+      # paragraph_form - the form object of the new paragraph
+      def initialize(collaborative_draft, current_user)
+        @collaborative_draft = collaborative_draft
+        @current_user = current_user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid and the collaborative_draft is published.
+      # - :invalid if the collaborative_draft's author is not the current user.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless @collaborative_draft.open?
+        return broadcast(:invalid) unless @collaborative_draft.authored_by? @current_user
+
+        transaction do
+          reject_access_to_collaborative_draft
+          publish_collaborative_draft
+          create_paragraph!
+          link_collaborative_draft_and_paragraph
+        end
+
+        broadcast(:ok, @new_paragraph)
+      end
+
+      attr_accessor :new_paragraph
+
+      private
+
+      def reject_access_to_collaborative_draft
+        @collaborative_draft.requesters.each do |requester_user|
+          RejectAccessToCollaborativeDraft.call(@collaborative_draft, current_user, requester_user)
+        end
+      end
+
+      def publish_collaborative_draft
+        Decidim.traceability.update!(
+          @collaborative_draft,
+          @current_user,
+          { state: "published", published_at: Time.current },
+          visibility: "public-only"
+        )
+      end
+
+      def paragraph_attributes
+        fields = {}
+
+        parsed_title = Decidim::ContentProcessor.parse_with_processor(:hashtag, @collaborative_draft.title, current_organization: @collaborative_draft.organization).rewrite
+        parsed_body = Decidim::ContentProcessor.parse_with_processor(:hashtag, @collaborative_draft.body, current_organization: @collaborative_draft.organization).rewrite
+
+        fields[:title] = { I18n.locale => parsed_title }
+        fields[:body] = { I18n.locale => parsed_body }
+        fields[:component] = @collaborative_draft.component
+        fields[:scope] = @collaborative_draft.scope
+        fields[:address] = @collaborative_draft.address
+        fields[:published_at] = Time.current
+
+        fields
+      end
+
+      def create_paragraph!
+        @new_paragraph = Decidim.traceability.perform_action!(
+          :create,
+          Decidim::EnhancedTextwork::Paragraph,
+          @current_user,
+          visibility: "public-only"
+        ) do
+          new_paragraph = Paragraph.new(paragraph_attributes)
+          new_paragraph.coauthorships = @collaborative_draft.coauthorships
+          new_paragraph.category = @collaborative_draft.category
+          new_paragraph.attachments = @collaborative_draft.attachments
+          new_paragraph.save!
+          new_paragraph
+        end
+      end
+
+      def link_collaborative_draft_and_paragraph
+        @collaborative_draft.link_resources(@new_paragraph, "created_from_collaborative_draft")
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/publish_paragraph.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic when a user publishes a draft paragraph.
+    class PublishParagraph < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # paragraph     - The paragraph to publish.
+      # current_user - The current user.
+      def initialize(paragraph, current_user)
+        @paragraph = paragraph
+        @current_user = current_user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid and the paragraph is published.
+      # - :invalid if the paragraph's author is not the current user.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless @paragraph.authored_by?(@current_user)
+
+        transaction do
+          publish_paragraph
+          increment_scores
+          send_notification
+          send_notification_to_participatory_space
+        end
+
+        broadcast(:ok, @paragraph)
+      end
+
+      private
+
+      # This will be the PaperTrail version that is
+      # 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
+        title = reset(:title)
+        body = reset(:body)
+
+        Decidim.traceability.perform_action!(
+          "publish",
+          @paragraph,
+          @current_user,
+          visibility: "public-only"
+        ) do
+          @paragraph.update title: title, body: body, published_at: Time.current
+        end
+      end
+
+      # Reset the attribute to an empty string and return the old value
+      def reset(attribute)
+        attribute_value = @paragraph[attribute]
+        PaperTrail.request(enabled: false) do
+          # rubocop:disable Rails/SkipsModelValidations
+          @paragraph.update_attribute attribute, ""
+          # rubocop:enable Rails/SkipsModelValidations
+        end
+        attribute_value
+      end
+
+      def send_notification
+        return if @paragraph.coauthorships.empty?
+
+        Decidim::EventsManager.publish(
+          event: "decidim.events.enhanced_textwork.paragraph_published",
+          event_class: Decidim::EnhancedTextwork::PublishParagraphEvent,
+          resource: @paragraph,
+          followers: coauthors_followers
+        )
+      end
+
+      def send_notification_to_participatory_space
+        Decidim::EventsManager.publish(
+          event: "decidim.events.enhanced_textwork.paragraph_published",
+          event_class: Decidim::EnhancedTextwork::PublishParagraphEvent,
+          resource: @paragraph,
+          followers: @paragraph.participatory_space.followers - coauthors_followers,
+          extra: {
+            participatory_space: true
+          }
+        )
+      end
+
+      def coauthors_followers
+        @coauthors_followers ||= @paragraph.authors.flat_map(&:followers)
+      end
+
+      def increment_scores
+        @paragraph.coauthorships.find_each do |coauthorship|
+          if coauthorship.user_group
+            Decidim::Gamification.increment_score(coauthorship.user_group, :paragraphs)
+          else
+            Decidim::Gamification.increment_score(coauthorship.author, :paragraphs)
+          end
+        end
+      end
+    end
+  end
+end