decidim-enhanced_textwork 1.0.0

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic to reject a user request to
+    # contribute to a collaborative draft.
+    class RejectAccessToCollaborativeDraft < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # form         - A form object with the params.
+      # collaborative_draft     - A Decidim::EnhancedTextwork::CollaborativeDraft object.
+      # current_user - The current user.
+      # requester_user - The user that requested to collaborate.
+      def initialize(form, current_user)
+        @form = form
+        @collaborative_draft = form.collaborative_draft
+        @current_user = current_user
+        @requester_user = form.requester_user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid.
+      # - :invalid if it wasn't valid and we couldn't proceed.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) if @form.invalid?
+        return broadcast(:invalid) if @current_user.nil?
+
+        @collaborative_draft.requesters.delete @requester_user
+
+        notify_collaborative_draft_requester
+        notify_collaborative_draft_authors
+        broadcast(:ok, @requester_user)
+      end
+
+      private
+
+      def notify_collaborative_draft_authors
+        Decidim::EventsManager.publish(
+          event: "decidim.events.enhanced_textwork.collaborative_draft_access_rejected",
+          event_class: Decidim::EnhancedTextwork::CollaborativeDraftAccessRejectedEvent,
+          resource: @collaborative_draft,
+          affected_users: @collaborative_draft.authors,
+          extra: {
+            requester_id: @requester_user.id
+          }
+        )
+      end
+
+      def notify_collaborative_draft_requester
+        Decidim::EventsManager.publish(
+          event: "decidim.events.enhanced_textwork.collaborative_draft_access_requester_rejected",
+          event_class: Decidim::EnhancedTextwork::CollaborativeDraftAccessRequesterRejectedEvent,
+          resource: @collaborative_draft,
+          affected_users: [@requester_user]
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic when a user requests access
+    # to edit a collaborative draft.
+    class RequestAccessToCollaborativeDraft < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # form         - A form object with the params.
+      # collaborative_draft     - A Decidim::EnhancedTextwork::CollaborativeDraft object.
+      # current_user - The current user and requester user
+      def initialize(form, current_user)
+        @form = form
+        @collaborative_draft = form.collaborative_draft
+        @current_user = current_user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid.
+      # - :invalid if it wasn't valid and we couldn't proceed.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) if @form.invalid?
+        return broadcast(:invalid) if @current_user.nil?
+
+        @collaborative_draft.collaborator_requests.create!(user: @current_user)
+        notify_collaborative_draft_authors
+        broadcast(:ok, @collaborative_draft)
+      end
+
+      private
+
+      def notify_collaborative_draft_authors
+        Decidim::EventsManager.publish(
+          event: "decidim.events.enhanced_textwork.collaborative_draft_access_requested",
+          event_class: Decidim::EnhancedTextwork::CollaborativeDraftAccessRequestedEvent,
+          resource: @collaborative_draft,
+          affected_users: @collaborative_draft.authors,
+          extra: {
+            requester_id: @current_user.id
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic when a user unvotes a paragraph.
+    class UnvoteParagraph < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # paragraph     - A Decidim::EnhancedTextwork::Paragraph object.
+      # 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, together with the paragraph.
+      # - :invalid if the form wasn't valid and we couldn't proceed.
+      #
+      # Returns nothing.
+      def call
+        ActiveRecord::Base.transaction do
+          ParagraphVote.where(
+            author: @current_user,
+            paragraph: @paragraph
+          ).destroy_all
+
+          update_temporary_votes
+        end
+
+        Decidim::Gamification.decrement_score(@current_user, :paragraph_votes)
+
+        broadcast(:ok, @paragraph)
+      end
+
+      private
+
+      def component
+        @component ||= @paragraph.component
+      end
+
+      def minimum_votes_per_user
+        component.settings.minimum_votes_per_user
+      end
+
+      def minimum_votes_per_user?
+        minimum_votes_per_user.positive?
+      end
+
+      def update_temporary_votes
+        return unless minimum_votes_per_user? && user_votes.count < minimum_votes_per_user
+
+        user_votes.each { |vote| vote.update(temporary: true) }
+      end
+
+      def user_votes
+        @user_votes ||= ParagraphVote.where(
+          author: @current_user,
+          paragraph: Paragraph.where(component: component)
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic when a user updates a collaborative_draft.
+    class UpdateCollaborativeDraft < Rectify::Command
+      include HashtagsMethods
+
+      # Public: Initializes the command.
+      #
+      # form         - A form object with the params.
+      # current_user - The current user.
+      # collaborative_draft - the collaborative_draft to update.
+      def initialize(form, current_user, collaborative_draft)
+        @form = form
+        @current_user = current_user
+        @collaborative_draft = collaborative_draft
+      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?
+        return broadcast(:invalid) unless collaborative_draft.editable_by?(current_user)
+
+        transaction do
+          update_collaborative_draft
+        end
+
+        broadcast(:ok, collaborative_draft)
+      end
+
+      private
+
+      attr_reader :form, :collaborative_draft, :current_user
+
+      def update_collaborative_draft
+        Decidim.traceability.update!(
+          @collaborative_draft,
+          @current_user,
+          attributes,
+          visibility: "public-only"
+        )
+      end
+
+      def attributes
+        {
+          title: title_with_hashtags,
+          body: body_with_hashtags,
+          category: form.category,
+          scope: form.scope,
+          address: form.address,
+          latitude: form.latitude,
+          longitude: form.longitude
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic when a user updates a paragraph.
+    class UpdateParagraph < Rectify::Command
+      include ::Decidim::MultipleAttachmentsMethods
+      include GalleryMethods
+      include HashtagsMethods
+
+      # Public: Initializes the command.
+      #
+      # form         - A form object with the params.
+      # current_user - The current user.
+      # paragraph - the paragraph to update.
+      def initialize(form, current_user, paragraph)
+        @form = form
+        @current_user = current_user
+        @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 invalid?
+
+        if process_attachments?
+          build_attachments
+          return broadcast(:invalid) if attachments_invalid?
+        end
+
+        if process_gallery?
+          build_gallery
+          return broadcast(:invalid) if gallery_invalid?
+        end
+
+        transaction do
+          if @paragraph.draft?
+            update_draft
+          else
+            update_paragraph
+          end
+          create_gallery if process_gallery?
+          create_attachments if process_attachments?
+
+          photo_cleanup!
+          document_cleanup!
+        end
+
+        broadcast(:ok, paragraph)
+      end
+
+      private
+
+      attr_reader :form, :paragraph, :current_user, :attachment
+
+      def invalid?
+        form.invalid? || !paragraph.editable_by?(current_user) || paragraph_limit_reached?
+      end
+
+      # Prevent PaperTrail from creating an additional version
+      # in the paragraph multi-step creation process (step 3: complete)
+      #
+      # A first version will be created in step 4: publish
+      # for diff rendering in the paragraph control version
+      def update_draft
+        PaperTrail.request(enabled: false) do
+          @paragraph.update(attributes)
+          @paragraph.coauthorships.clear
+          @paragraph.add_coauthor(current_user, user_group: user_group)
+        end
+      end
+
+      def update_paragraph
+        @paragraph = Decidim.traceability.update!(
+          @paragraph,
+          current_user,
+          attributes,
+          visibility: "public-only"
+        )
+        @paragraph.coauthorships.clear
+        @paragraph.add_coauthor(current_user, user_group: user_group)
+      end
+
+      def attributes
+        {
+          title: {
+            I18n.locale => title_with_hashtags
+          },
+          body: {
+            I18n.locale => body_with_hashtags
+          },
+          category: form.category,
+          scope: form.scope,
+          address: form.address,
+          latitude: form.latitude,
+          longitude: form.longitude
+        }
+      end
+
+      def paragraph_limit_reached?
+        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).published.where.not(id: paragraph.id).except_withdrawn
+      end
+
+      def user_group_paragraphs
+        Paragraph.from_user_group(user_group).where(component: form.current_component).published.where.not(id: paragraph.id).except_withdrawn
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic when a user votes a paragraph.
+    class VoteParagraph < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # paragraph     - A Decidim::EnhancedTextwork::Paragraph object.
+      # 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, together with the paragraph vote.
+      # - :invalid if the form wasn't valid and we couldn't proceed.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) if @paragraph.maximum_votes_reached? && !@paragraph.can_accumulate_supports_beyond_threshold
+
+        build_paragraph_vote
+        return broadcast(:invalid) unless vote.valid?
+
+        ActiveRecord::Base.transaction do
+          @paragraph.with_lock do
+            vote.save!
+            update_temporary_votes
+          end
+        end
+
+        Decidim::Gamification.increment_score(@current_user, :paragraph_votes)
+
+        broadcast(:ok, vote)
+      end
+
+      attr_reader :vote
+
+      private
+
+      def component
+        @component ||= @paragraph.component
+      end
+
+      def minimum_votes_per_user
+        component.settings.minimum_votes_per_user
+      end
+
+      def minimum_votes_per_user?
+        minimum_votes_per_user.positive?
+      end
+
+      def update_temporary_votes
+        return unless minimum_votes_per_user? && user_votes.count >= minimum_votes_per_user
+
+        user_votes.each { |vote| vote.update(temporary: false) }
+      end
+
+      def user_votes
+        @user_votes ||= ParagraphVote.where(
+          author: @current_user,
+          paragraph: Paragraph.where(component: component)
+        )
+      end
+
+      def build_paragraph_vote
+        @vote = @paragraph.votes.build(
+          author: @current_user,
+          temporary: minimum_votes_per_user?
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic when a user withdraws a collaborative_draft.
+    class WithdrawCollaborativeDraft < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # collaborative_draft     - The collaborative_draft to withdraw.
+      # current_user - The current user.
+      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) if @collaborative_draft.withdrawn?
+        return broadcast(:invalid) if @collaborative_draft.published?
+        return broadcast(:invalid) unless @collaborative_draft.authored_by? @current_user
+
+        transaction do
+          @collaborative_draft.requesters.each do |requester_user|
+            RejectAccessToCollaborativeDraft.call(@collaborative_draft, current_user, requester_user)
+          end
+
+          withdraw_collaborative_draft
+          send_notification_to_authors
+        end
+
+        broadcast(:ok, @collaborative_draft)
+      end
+
+      private
+
+      def withdraw_collaborative_draft
+        Decidim.traceability.update!(
+          @collaborative_draft,
+          @current_user,
+          state: "withdrawn"
+        )
+      end
+
+      def send_notification_to_authors
+        recipients = @collaborative_draft.authors - [@current_user]
+        return if recipients.blank?
+
+        Decidim::EventsManager.publish(
+          event: "decidim.events.enhanced_textwork.collaborative_draft_withdrawn",
+          event_class: Decidim::EnhancedTextwork::CollaborativeDraftWithdrawnEvent,
+          resource: @collaborative_draft,
+          affected_users: recipients.uniq,
+          extra: {
+            author_id: @current_user.id
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic when a user withdraws a new paragraph.
+    class WithdrawParagraph < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # paragraph     - The paragraph to withdraw.
+      # 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, together with the paragraph.
+      # - :has_supports if the paragraph already has supports or does not belong to current user.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:has_supports) if @paragraph.votes.any?
+
+        transaction do
+          change_paragraph_state_to_withdrawn
+          reject_emendations_if_any
+        end
+
+        broadcast(:ok, @paragraph)
+      end
+
+      private
+
+      def change_paragraph_state_to_withdrawn
+        @paragraph.update state: "withdrawn"
+      end
+
+      def reject_emendations_if_any
+        return if @paragraph.emendations.empty?
+
+        @paragraph.emendations.each do |emendation|
+          @form = form(Decidim::Amendable::RejectForm).from_params(id: emendation.amendment.id)
+          result = Decidim::Amendable::Reject.call(@form)
+          return result[:ok] if result[:ok]
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/enhanced_textwork/admin/filterable.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      module Filterable
+        extend ActiveSupport::Concern
+
+        included do
+          include Decidim::Admin::Filterable
+
+          helper Decidim::EnhancedTextwork::Admin::FilterableHelper
+
+          private
+
+          # Comment about participatory_texts_enabled.
+          def base_query
+            return collection.order(:position) if current_component.settings.participatory_texts_enabled?
+
+            accessible_paragraphs_collection
+          end
+
+          def accessible_paragraphs_collection
+            return collection if current_participatory_space.user_roles(:valuator).where(user: current_user).empty?
+
+            collection.with_valuation_assigned_to(current_user, current_participatory_space)
+          end
+
+          def search_field_predicate
+            :id_string_or_title_cont
+          end
+
+          def filters
+            [
+              :is_emendation_true,
+              :state_eq,
+              :state_null,
+              :scope_id_eq,
+              :category_id_eq,
+              :valuator_role_ids_has
+            ]
+          end
+
+          def filters_with_values
+            {
+              is_emendation_true: %w(true false),
+              state_eq: paragraph_states,
+              scope_id_eq: scope_ids_hash(scopes.top_level),
+              category_id_eq: category_ids_hash(categories.first_class),
+              valuator_role_ids_has: valuator_role_ids
+            }
+          end
+
+          # Can't user `super` here, because it does not belong to a superclass
+          # but to a concern.
+          def dynamically_translated_filters
+            [:scope_id_eq, :category_id_eq, :valuator_role_ids_has]
+          end
+
+          def valuator_role_ids
+            current_participatory_space.user_roles(:valuator).pluck(:id)
+          end
+
+          def translated_valuator_role_ids_has(valuator_role_id)
+            user_role = current_participatory_space.user_roles(:valuator).find_by(id: valuator_role_id)
+            user_role&.user&.name
+          end
+
+          # An Array<Symbol> of possible values for `state_eq` filter.
+          # Excludes the states that cannot be filtered with the ransack predicate.
+          # A link to filter by "Not answered" will be added in:
+          # Decidim::EnhancedTextwork::Admin::FilterableHelper#extra_dropdown_submenu_options_items
+          def paragraph_states
+            Paragraph::POSSIBLE_STATES.without("not_answered")
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/enhanced_textwork/admin/picker.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      module Picker
+        extend ActiveSupport::Concern
+
+        included do
+          helper Decidim::EnhancedTextwork::Admin::ParagraphsPickerHelper
+        end
+
+        def paragraphs_picker
+          render :paragraphs_picker, layout: false
+        end
+      end
+    end
+  end
+end