decidim-proposals 0.29.3 → 0.30.0.rc1

data/app/commands/decidim/proposals/admin/import_proposals.rb

@@ -22,8 +22,7 @@ module Decidim
         def call
           return broadcast(:invalid) unless form.valid?
 
-          import_proposals
-          broadcast(:ok)
+          broadcast(:ok, import_proposals)
         end
 
         private
@@ -31,11 +30,65 @@ module Decidim
         attr_reader :form
 
         def import_proposals
-          ImportProposalsJob.perform_later(form.as_json.merge({
-                                                                "current_user_id" => form.current_user.id,
-                                                                "current_organization_id" => form.current_organization.id,
-                                                                "current_component_id" => form.current_component.id
-                                                              }))
+          proposals.map do |original_proposal|
+            next if proposal_already_copied?(original_proposal, target_component)
+
+            Decidim::Proposals::ProposalBuilder.copy(
+              original_proposal,
+              author: proposal_author,
+              action_user: form.current_user,
+              extra_attributes: {
+                "component" => target_component
+              }.merge(proposal_answer_attributes(original_proposal))
+            )
+          end.compact
+        end
+
+        def proposals
+          @proposals = Decidim::Proposals::Proposal
+                       .where(component: origin_component)
+
+          @proposals = if @form.states.include?("not_answered")
+                         @proposals.not_answered.or(@proposals.where(id: @proposals.only_status(@form.states).pluck(:id)))
+                       else
+                         @proposals.only_status(@form.states)
+                       end
+
+          @proposals
+        end
+
+        def origin_component
+          @form.origin_component
+        end
+
+        def target_component
+          @form.current_component
+        end
+
+        def proposal_already_copied?(original_proposal, target_component)
+          # Note: we are including also proposals from unpublished components
+          # because otherwise duplicates could be created until the component is
+          # published.
+          original_proposal.linked_resources(:proposals, "copied_from_component", component_published: false).any? do |proposal|
+            proposal.component == target_component
+          end
+        end
+
+        def proposal_author
+          form.keep_authors ? nil : @form.current_organization
+        end
+
+        def proposal_answer_attributes(original_proposal)
+          return {} unless form.keep_answers
+
+          state = Decidim::Proposals::ProposalState.where(component: target_component, token: original_proposal.state).first
+
+          {
+            answer: original_proposal.answer,
+            answered_at: original_proposal.answered_at,
+            proposal_state: state,
+            state_published_at: original_proposal.state_published_at
+          }
         end
       end
     end

data/app/commands/decidim/proposals/admin/merge_proposals.rb

@@ -32,7 +32,7 @@ module Decidim
         def merge_proposals
           transaction do
             merged_proposal = create_new_proposal
-            merged_proposal.link_resources(proposals_to_link, "copied_from_component")
+            merged_proposal.link_resources(proposals_to_link, "merged_from_component")
             form.proposals.each(&:destroy!) if form.same_component?
             merged_proposal
           end
@@ -46,7 +46,7 @@ module Decidim
 
         def previous_links
           @previous_links ||= form.proposals.flat_map do |proposal|
-            proposal.linked_resources(:proposals, "copied_from_component")
+            proposal.linked_resources(:proposals, "merged_from_component")
           end
         end
 

data/app/commands/decidim/proposals/admin/proposal_notes_methods.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      # A module with common methods of proposal notes commands
+      module ProposalNotesMethods
+        private
+
+        def parsed_body
+          @parsed_body ||= Decidim::ContentProcessor.parse_with_processor(:user, form.body, current_organization: form.current_organization)
+        end
+
+        def mentioned_users
+          @mentioned_users ||= parsed_body.metadata[:user].users
+        end
+
+        def rewritten_body
+          @rewritten_body ||= parsed_body.rewrite
+        end
+
+        def proposal_valuators
+          @proposal_valuators ||= Decidim::Proposals::ValuationAssignment.where(proposal:).filter_map do |assignment|
+            assignment.valuator unless assignment.valuator == form.current_user
+          end
+        end
+
+        def admins
+          @admins ||= Decidim::User.org_admins_except_me(form.current_user).all
+        end
+
+        def space_admins
+          @space_admins ||= proposal.participatory_space.user_roles("admin").includes(:user).filter_map do |role|
+            role.user unless role.user == form.current_user
+          end
+        end
+
+        def mentioned_admins_or_valuators
+          mentioned_users.select do |user|
+            admins.exists?(user.id) ||
+              space_admins.include?(user) ||
+              proposal_valuators.include?(user)
+          end
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/proposals/admin/reply_proposal_note.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      # A command with all the business logic when an admin creates a private note proposal reply.
+      class ReplyProposalNote < Decidim::Command
+        include ProposalNotesMethods
+
+        # Public: Initializes the command.
+        #
+        # form   - A form object with the params.
+        # parent - the note to reply.
+        def initialize(form, parent)
+          @form = form
+          @parent = parent
+          @proposal = parent.proposal
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid, together with the note proposal.
+        # - :invalid if the form was not valid and we could not proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if form.invalid? || invalid_parent?
+
+          create_proposal_note_reply
+          notify_parent_author
+          notify_mentioned
+
+          broadcast(:ok, proposal_note)
+        end
+
+        private
+
+        attr_reader :form, :proposal_note, :parent, :proposal
+
+        def invalid_parent?
+          parent.blank? || parent.reply?
+        end
+
+        def create_proposal_note_reply
+          @proposal_note = Decidim.traceability.create!(
+            ProposalNote,
+            form.current_user,
+            {
+              body: rewritten_body,
+              proposal:,
+              parent:,
+              author: form.current_user
+            },
+            resource: {
+              title: proposal.title
+            }
+          )
+        end
+
+        def parent_author
+          @parent_author ||= parent.author
+        end
+
+        def notify_parent_author
+          return if form.current_user == parent_author
+
+          Decidim::EventsManager.publish(
+            event: "decidim.events.proposals.admin.proposal_note_replied",
+            event_class: Decidim::Proposals::Admin::ProposalNoteCreatedEvent,
+            resource: proposal,
+            affected_users: [parent_author],
+            extra: { note_author_id: form.current_user.id }
+          )
+        end
+
+        def notify_mentioned
+          affected_users = mentioned_admins_or_valuators - [parent_author]
+
+          return if affected_users.blank?
+
+          Decidim::EventsManager.publish(
+            event: "decidim.events.proposals.admin.proposal_note_mentioned",
+            event_class: Decidim::Proposals::Admin::ProposalNoteCreatedEvent,
+            resource: proposal,
+            affected_users:,
+            extra: { note_author_id: form.current_user.id }
+          )
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/proposals/admin/split_proposals.rb

@@ -53,13 +53,13 @@ module Decidim
           )
 
           proposals_to_link = links_for(original_proposal)
-          split_proposal.link_resources(proposals_to_link, "copied_from_component")
+          split_proposal.link_resources(proposals_to_link, "splitted_from_component")
         end
 
         def links_for(proposal)
           return proposal unless form.same_component?
 
-          proposal.linked_resources(:proposals, "copied_from_component")
+          proposal.linked_resources(:proposals, "splitted_from_component")
         end
       end
     end

data/app/commands/decidim/proposals/admin/update_proposal.rb

@@ -5,8 +5,7 @@ module Decidim
     module Admin
       # A command with all the business logic when a user updates a proposal.
       class UpdateProposal < Decidim::Command
-        include ::Decidim::AttachmentMethods
-        include GalleryMethods
+        include ::Decidim::MultipleAttachmentsMethods
         include HashtagsMethods
 
         # Public: Initializes the command.
@@ -31,23 +30,15 @@ module Decidim
           delete_attachment(form.attachment) if delete_attachment?
 
           if process_attachments?
-            @proposal.attachments.destroy_all
-
-            build_attachment
-            return broadcast(:invalid) if attachment_invalid?
-          end
-
-          if process_gallery?
-            build_gallery
-            return broadcast(:invalid) if gallery_invalid?
+            build_attachments
+            return broadcast(:invalid) if attachments_invalid?
           end
 
           transaction do
             update_proposal
             update_proposal_author
-            create_gallery if process_gallery?
-            create_attachment(weight: first_attachment_weight) if process_attachments?
-            photo_cleanup!
+            document_cleanup!(include_all_attachments: true)
+            create_attachments(first_weight: first_attachment_weight) if process_attachments?
           end
 
           broadcast(:ok, proposal)
@@ -69,8 +60,7 @@ module Decidim
             form.current_user,
             title: parsed_title,
             body: parsed_body,
-            category: form.category,
-            scope: form.scope,
+            taxonomizations: form.taxonomizations,
             address: form.address,
             latitude: form.latitude,
             longitude: form.longitude,
@@ -90,6 +80,10 @@ module Decidim
 
           proposal.photos.count
         end
+
+        def delete_attachment?
+          @form.attachment&.delete_file.present?
+        end
       end
     end
   end

data/app/commands/decidim/proposals/admin/update_proposal_taxonomies.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      #  A command with all the business logic when an admin batch updates proposals taxonomies.
+      class UpdateProposalTaxonomies < UpdateResourcesTaxonomies
+        include TranslatableAttributes
+        # Public: Initializes the command.
+        #
+        # taxonomy_ids - the taxonomy ids to update
+        # proposal_ids - the proposals ids to update.
+        def initialize(taxonomy_ids, proposal_ids, organization)
+          super(taxonomy_ids, Decidim::Proposals::Proposal.where(id: proposal_ids), organization)
+        end
+
+        def run_after_hooks(resource)
+          notify_author(resource) if resource.coauthorships.any?
+        end
+
+        private
+
+        def notify_author(proposal)
+          Decidim::EventsManager.publish(
+            event: "decidim.events.proposals.proposal_update_taxonomies",
+            event_class: Decidim::Proposals::UpdateProposalTaxonomiesEvent,
+            resource: proposal,
+            affected_users: proposal.notifiable_identities
+          )
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/proposals/cancel_coauthorship.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    # A command with all the business logic when a user cancels an invitation to be a coauthor.
+    class CancelCoauthorship < Decidim::Command
+      # Public: Initializes the command.
+      #
+      # proposal     - The proposal to add a coauthor to.
+      # coauthor - The user to invite as coauthor.
+      def initialize(proposal, coauthor)
+        @proposal = proposal
+        @coauthor = coauthor
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the proposal.
+      # - :invalid if the coauthor is not valid.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless @coauthor
+        return broadcast(:invalid) if @proposal.authors.include?(@coauthor)
+
+        @proposal.coauthor_invitations_for(@coauthor).destroy_all
+
+        broadcast(:ok)
+      end
+    end
+  end
+end

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

@@ -63,8 +63,7 @@ module Decidim
           draft = CollaborativeDraft.new(
             title: title_with_hashtags,
             body: body_with_hashtags,
-            category: form.category,
-            scope: form.scope,
+            taxonomizations: form.taxonomizations,
             component: form.component,
             address: form.address,
             latitude: form.latitude,

data/app/commands/decidim/proposals/create_proposal.rb

@@ -82,8 +82,7 @@ module Decidim
               component: form.component
             )
 
-            proposal.category = form.category if form.category_id.present?
-            proposal.scope = form.scope if form.scope_id.present?
+            proposal.taxonomizations = form.taxonomizations if form.taxonomizations.present?
             proposal.documents = form.documents if form.documents.present?
             proposal.address = form.address if form.has_address? && !form.geocoded?
             proposal.add_coauthor(@current_user, user_group:)

data/app/commands/decidim/proposals/invite_coauthor.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    # A command with all the business logic when a user invites a coauthor to a proposal
+    class InviteCoauthor < Decidim::Command
+      # Public: Initializes the command.
+      #
+      # proposal     - The proposal to add a coauthor to.
+      # coauthor - The user to invite as coauthor.
+      def initialize(proposal, coauthor)
+        @proposal = proposal
+        @coauthor = coauthor
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the proposal.
+      # - :invalid if the coauthor is not valid.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless @coauthor
+        return broadcast(:invalid) if @proposal.authors.include?(@coauthor)
+
+        transaction do
+          generate_notifications
+        end
+
+        broadcast(:ok)
+      end
+
+      private
+
+      def generate_notifications
+        Decidim::EventsManager.publish(
+          event: "decidim.events.proposals.coauthor_invited",
+          event_class: Decidim::Proposals::CoauthorInvitedEvent,
+          resource: @proposal,
+          affected_users: [@coauthor]
+        )
+      end
+    end
+  end
+end

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

@@ -62,7 +62,6 @@ module Decidim
         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
 
@@ -78,7 +77,7 @@ module Decidim
         ) do
           new_proposal = Proposal.new(proposal_attributes)
           new_proposal.coauthorships = @collaborative_draft.coauthorships
-          new_proposal.category = @collaborative_draft.category
+          new_proposal.taxonomies = @collaborative_draft.taxonomies
           new_proposal.attachments = @collaborative_draft.attachments
           new_proposal.save!
           new_proposal

data/app/commands/decidim/proposals/reject_coauthorship.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    # A command with all the business logic when a user rejects and invitation to be a proposal co-author
+    class RejectCoauthorship < Decidim::Command
+      # Public: Initializes the command.
+      #
+      # proposal     - The proposal to add a coauthor to.
+      # coauthor - The user to invite as coauthor.
+      def initialize(proposal, coauthor)
+        @proposal = proposal
+        @coauthor = coauthor
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the proposal.
+      # - :invalid if the coauthor is not valid.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless @coauthor
+        return broadcast(:invalid) if @proposal.authors.include?(@coauthor)
+
+        @proposal.coauthor_invitations_for(@coauthor).destroy_all
+        generate_notifications
+
+        broadcast(:ok)
+      end
+
+      private
+
+      def generate_notifications
+        # notify the author that the co-author has rejected the invitation
+        Decidim::EventsManager.publish(
+          event: "decidim.events.proposals.coauthor_rejected_invite",
+          event_class: Decidim::Proposals::CoauthorRejectedInviteEvent,
+          resource: @proposal,
+          affected_users: @proposal.authors,
+          extra: { coauthor_id: @coauthor.id }
+        )
+
+        # notify the co-author of his own decision
+        Decidim::EventsManager.publish(
+          event: "decidim.events.proposals.rejected_coauthorship",
+          event_class: Decidim::Proposals::RejectedCoauthorshipEvent,
+          resource: @proposal,
+          affected_users: [@coauthor]
+        )
+      end
+    end
+  end
+end

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

@@ -61,8 +61,7 @@ module Decidim
         {
           title: title_with_hashtags,
           body: body_with_hashtags,
-          category: form.category,
-          scope: form.scope,
+          taxonomizations: form.taxonomizations,
           address: form.address,
           latitude: form.latitude,
           longitude: form.longitude

data/app/commands/decidim/proposals/update_proposal.rb

@@ -98,8 +98,7 @@ module Decidim
           body: {
             I18n.locale => body_with_hashtags
           },
-          category: form.category,
-          scope: form.scope,
+          taxonomizations: form.taxonomizations,
           address: form.address,
           latitude: form.latitude,
           longitude: form.longitude

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

@@ -19,7 +19,11 @@ module Decidim
           def base_query
             return collection.order(:position) if current_component.settings.participatory_texts_enabled?
 
-            accessible_proposals_collection
+            return accessible_proposals_collection unless taxonomy_order_or_search?
+
+            # this is a trick to avoid duplicates when using search in associations as suggested in:
+            # https://activerecord-hackery.github.io/ransack/going-further/other-notes/#problem-with-distinct-selects
+            accessible_proposals_collection.includes(:taxonomies).joins(:taxonomies)
           end
 
           def accessible_proposals_collection

data/app/controllers/concerns/decidim/proposals/admin/needs_interpolations.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module Proposals
+    module Admin
+      module NeedsInterpolations
+        extend ActiveSupport::Concern
+
+        included do
+          def populate_interpolations(text, proposal)
+            return populate_string_interpolations(text, proposal) if text.is_a?(String)
+
+            populate_hash_interpolations(text, proposal)
+          end
+
+          def populate_hash_interpolations(hash, proposal)
+            return hash unless hash.is_a?(Hash)
+
+            hash.transform_values do |value|
+              populate_interpolations(value, proposal)
+            end
+          end
+
+          def populate_string_interpolations(value, proposal)
+            value = value.gsub("%{organization}", translated_attribute(proposal.organization.name))
+            value = value.gsub("%{name}", author_name(proposal))
+            value.gsub("%{admin}", current_user.name)
+          end
+
+          def author_name(proposal)
+            name = proposal.creator_author.try(:title) || proposal.creator_author.try(:name)
+            translated_attribute(name)
+          end
+        end
+      end
+    end
+  end
+end