decidim-core 0.18.1 → 0.19.0

data/app/commands/decidim/amendable/destroy_draft.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Amendable
+    # A command with all the business logic when a user starts amending a resource.
+    class DestroyDraft < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # amendment     - The amendment to destroy.
+      # current_user  - The current user.
+      def initialize(amendment, current_user)
+        @amendment = amendment
+        @amendable = amendment.amendable
+        @emendation = amendment.emendation
+        @amender = amendment.amender
+        @current_user = current_user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the amendable.
+      # - :invalid if the amendment is not a draft.
+      # - :invalid if the amender is not the current user.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless amendment.draft? && amender == current_user
+
+        emendation.destroy!
+        amendment.delete
+
+        broadcast(:ok, amendable)
+      end
+
+      private
+
+      attr_reader :amendment, :amendable, :emendation, :amender, :current_user
+    end
+  end
+end

data/app/commands/decidim/amendable/promote.rb

@@ -10,8 +10,11 @@ module Decidim
       # amendable - The amendable resource.
       def initialize(form)
         @form = form
+        @amendment = form.amendment
         @emendation = form.emendation
         @amendable = form.amendable
+        @amender = form.amender
+        @current_user = form.current_user
       end
 
       # Executes the command. Broadcasts these events:
@@ -21,11 +24,12 @@ module Decidim
       #
       # Returns nothing.
       def call
-        return broadcast(:invalid) if form.invalid?
+        return broadcast(:invalid) unless form.valid? && amendment.rejected? && amender == current_user
 
         transaction do
           promote_emendation!
           notify_amendable_and_emendation_authors_and_followers
+          link_promoted_emendation_and_proposal
         end
 
         broadcast(:ok, @promoted_emendation)
@@ -33,23 +37,21 @@ module Decidim
 
       private
 
-      attr_reader :form
+      attr_reader :form, :amendment, :amender, :current_user
 
-      # The log of this action contains unique information
-      # that is used to show/hide the promote button
-      #
-      # extra_log_info = { promoted_form: emendation.id }
+      # The log of this action contains unique information:
+      # extra_log_info = { promoted_from: emendation.id }
       def promote_emendation!
         @promoted_emendation = Decidim.traceability.perform_action!(
           "promote",
-          @emendation.amendable_type.constantize,
+          @emendation.class,
           @emendation.creator_author,
           visibility: "public-only",
           promoted_from: @emendation.id
         ) do
-          promoted_emendation = @emendation.amendable_type.constantize.new(form.emendation_params)
+          promoted_emendation = @emendation.class.new(form.emendation_params)
           promoted_emendation.component = @emendation.component
-          promoted_emendation.published_at = Time.current if proposal?
+          promoted_emendation&.published_at = Time.current
           promoted_emendation.add_coauthor(@emendation.creator_author)
           promoted_emendation.save!
           promoted_emendation
@@ -69,8 +71,8 @@ module Decidim
         )
       end
 
-      def proposal?
-        @amendable.amendable_type == "Decidim::Proposals::Proposal"
+      def link_promoted_emendation_and_proposal
+        @promoted_emendation.link_resources(@emendation, "created_from_rejected_emendation")
       end
     end
   end

data/app/commands/decidim/amendable/publish_draft.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Amendable
+    # A command with all the business logic when a user publishes an amendment draft.
+    class PublishDraft < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # form         - A form object with the params.
+      def initialize(form)
+        @form = form
+        @amendment = form.amendment
+        @amendable = form.amendable
+        @emendation = form.emendation
+        @amender = form.amender
+        @current_user = form.current_user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the amend.
+      # - :invalid if the amendment is not a draft.
+      # - :invalid if the form isn't valid or the amender is not the current user.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless form.valid? && amendment.draft? && amender == current_user
+
+        transaction do
+          set_first_emendation_version
+          publish_emendation
+          change_amendment_state_to_evaluating
+          notify_amendable_authors_and_followers
+        end
+
+        broadcast(:ok, emendation)
+      end
+
+      private
+
+      attr_reader :form, :amendment, :amendable, :emendation, :amender, :current_user
+
+      # To be able to diff amendments we store the original attributes being amended
+      # in the first PaperTrail::Version.
+      def set_first_emendation_version
+        emendation.update(form.amendable_params)
+      end
+
+      # This will be the PaperTrail version that gets compared to the amended proposal.
+      def publish_emendation
+        Decidim.traceability.perform_action!(
+          "publish",
+          emendation,
+          current_user,
+          visibility: "public-only"
+        ) do
+          emendation.update(form.emendation_params.merge(published_at: Time.current))
+        end
+      end
+
+      def change_amendment_state_to_evaluating
+        emendation.amendment.update(state: "evaluating")
+      end
+
+      def notify_amendable_authors_and_followers
+        Decidim::EventsManager.publish(
+          event: "decidim.events.amendments.amendment_created",
+          event_class: Decidim::Amendable::AmendmentCreatedEvent,
+          resource: amendable,
+          affected_users: amendable.notifiable_identities,
+          followers: amendable.followers - amendable.notifiable_identities
+        )
+      end
+    end
+  end
+end

data/app/commands/decidim/amendable/update_draft.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Amendable
+    # A command with all the business logic when a user updates and amendment draft.
+    class UpdateDraft < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # form         - A form object with the params.
+      def initialize(form)
+        @form = form
+        @amendment = form.amendment
+        @amender = form.amender
+        @emendation = form.emendation
+        @current_user = form.current_user
+        @user_group = Decidim::UserGroup.find_by(id: form.user_group_id)
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the amend.
+      # - :invalid if the amendment is not a draft.
+      # - :invalid if the form isn't valid or the amender is not the current user.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless form.valid? && amendment.draft? && amender == current_user
+
+        transaction do
+          update_draft
+        end
+
+        broadcast(:ok, @amendment)
+      end
+
+      private
+
+      attr_reader :form, :amendment, :amender, :emendation, :current_user, :user_group
+
+      # Prevent PaperTrail from creating an additional version
+      # in the amendment multi-step creation process (step 3: complete)
+      #
+      # A first version will be created in step 4: publish
+      # for diff rendering in the amendment control version
+      def update_draft
+        PaperTrail.request(enabled: false) do
+          emendation.assign_attributes(form.emendation_params)
+          emendation.add_author(current_user, user_group)
+          emendation.save!
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/amendable/withdraw.rb

@@ -2,15 +2,17 @@
 
 module Decidim
   module Amendable
-    # A command with all the business logic when a user starts amending a resource.
+    # A command with all the business logic to withdraw an amendment.
     class Withdraw < Rectify::Command
       # Public: Initializes the command.
       #
-      # emendation     - The resource to withdraw.
-      # current_user - The current user.
-      def initialize(emendation, current_user)
-        @emendation = emendation
+      # amendment     - The amendment to withdraw.
+      # current_user  - The current user.
+      def initialize(amendment, current_user)
+        @amendment = amendment
+        @amender = amendment.amender
         @current_user = current_user
+        @emendation = amendment.emendation
       end
 
       # Executes the command. Broadcasts these events:
@@ -20,26 +22,40 @@ module Decidim
       #
       # Returns nothing.
       def call
-        return broadcast(:invalid) if @emendation.votes.any?
+        return broadcast(:invalid) unless emendation.votes.empty? && amender == current_user
 
         transaction do
-          change_amendment_state_to_withdrawn
-          change_emendation_state_to_withdrawn
+          withdraw_amendment!
+          withdraw_emendation!
         end
 
-        broadcast(:ok, @emendation)
+        broadcast(:ok, emendation)
       end
 
       private
 
-      def change_amendment_state_to_withdrawn
-        @emendation.amendment.update state: "withdrawn"
+      attr_reader :amendment, :amender, :current_user, :emendation
+
+      def withdraw_amendment!
+        @amendment = Decidim.traceability.update!(
+          amendment,
+          current_user,
+          { state: "withdrawn" },
+          visibility: "public-only"
+        )
       end
 
-      def change_emendation_state_to_withdrawn
-        # rubocop:disable Rails/SkipsModelValidations
-        @emendation.update_attribute :state, "withdrawn"
-        # rubocop:enable Rails/SkipsModelValidations
+      # Unlike other Amendable commands, we need to update the state of the
+      # emendation for the scope Decidim::Proposals::Proposal::expect_withdrawn
+      # to be able to retrieve rejected emendations.
+      #
+      # Because we are modifying the emendation itself, we need to prevent
+      # PaperTrail from creating an additional version to ensure that this
+      # change does not appear in the diff renderer of the emendation page.
+      def withdraw_emendation!
+        PaperTrail.request(enabled: false) do
+          emendation.update!(state: "withdrawn")
+        end
       end
     end
   end

data/app/commands/decidim/create_follow.rb

@@ -40,6 +40,7 @@ module Decidim
 
     def increment_score
       return unless form.followable.is_a? Decidim::User
+
       Decidim::Gamification.increment_score(form.followable, :followers)
     end
   end

data/app/commands/decidim/create_omniauth_registration.rb

@@ -21,7 +21,12 @@ module Decidim
       verify_oauth_signature!
 
       begin
-        return broadcast(:ok, existing_identity.user) if existing_identity
+        if existing_identity
+          user = existing_identity.user
+          verify_user_confirmed(user)
+
+          return broadcast(:ok, user)
+        end
         return broadcast(:invalid) if form.invalid?
 
         transaction do
@@ -31,8 +36,8 @@ module Decidim
         trigger_omniauth_registration
 
         broadcast(:ok, @user)
-      rescue ActiveRecord::RecordInvalid => error
-        broadcast(:error, error.record)
+      rescue ActiveRecord::RecordInvalid => e
+        broadcast(:error, e.record)
       end
     end
 
@@ -48,7 +53,12 @@ module Decidim
         organization: organization
       )
 
-      unless @user.persisted?
+      if @user.persisted?
+        # If user has left the account unconfirmed and later on decides to sign
+        # in with omniauth with an already verified account, the account needs
+        # to be marked confirmed.
+        @user.skip_confirmation! if !@user.confirmed? && @user.email == verified_email
+      else
         @user.email = (verified_email || form.email)
         @user.name = form.name
         @user.nickname = form.normalized_nickname
@@ -84,6 +94,14 @@ module Decidim
       )
     end
 
+    def verify_user_confirmed(user)
+      return true if user.confirmed?
+      return false if user.email != verified_email
+
+      user.skip_confirmation!
+      user.save!
+    end
+
     def verify_oauth_signature!
       raise InvalidOauthSignature, "Invalid oauth signature: #{form.oauth_signature}" unless signature_valid?
     end

data/app/commands/decidim/create_registration.rb

@@ -19,6 +19,7 @@ module Decidim
     def call
       return broadcast(:invalid) if form.invalid?
 
+      delete_pending_invited_user
       create_user
 
       broadcast(:ok, @user)
@@ -30,6 +31,10 @@ module Decidim
 
     attr_reader :form
 
+    def delete_pending_invited_user
+      User.invitation_not_accepted.where(email: form.email).delete_all
+    end
+
     def create_user
       @user = User.create!(
         email: form.email,

data/app/commands/decidim/delete_follow.rb

@@ -38,6 +38,7 @@ module Decidim
     def decrement_score
       followable = form.follow.followable
       return unless followable.is_a? Decidim::User
+
       Decidim::Gamification.decrement_score(followable, :followers)
     end
   end

data/app/commands/decidim/search.rb

@@ -52,6 +52,7 @@ module Decidim
 
     def paginate(collection)
       return collection if page_params.blank?
+
       collection.page(page_params[:page]).per(page_params[:per_page])
     end
 

data/app/controllers/concerns/decidim/action_authorization.rb

@@ -26,6 +26,8 @@ module Decidim
         "#{action}-#{resource.component.id}-#{resource.resource_manifest.name}-#{resource.id}"
       elsif resource && permissions_holder
         "#{action}-#{permissions_holder.class.name}-#{permissions_holder.id}-#{resource.resource_manifest.name}-#{resource.id}"
+      elsif permissions_holder
+        "#{action}-#{permissions_holder.class.name}-#{permissions_holder.id}"
       else
         "#{action}-#{current_component.id}"
       end

data/app/controllers/concerns/decidim/amendments_controller.rb

@@ -4,34 +4,119 @@ module Decidim
   class AmendmentsController < Decidim::ApplicationController
     include Decidim::ApplicationHelper
     include FormFactory
+    helper Decidim::ResourceReferenceHelper
 
     before_action :authenticate_user!
-    helper_method :amendable, :emendation
+    helper_method :amendment, :amendable, :emendation, :similar_emendations
+    before_action :ensure_is_draft_from_user, only: [:compare_draft, :edit_draft, :update_draft, :destroy_draft, :preview_draft, :publish_draft]
 
     def new
-      @form = Decidim::Amendable::CreateForm.from_params(params)
+      raise ActionController::RoutingError, "Not Found" unless amendable
+
+      enforce_permission_to :create, :amendment, current_component: amendable.component
+
+      amendment_draft = amendable.amendments.find_by(amender: current_user.id, state: "draft")
+
+      if amendment_draft
+        redirect_to edit_draft_amend_path(amendment_draft)
+      else
+        @form = form(Decidim::Amendable::CreateForm).from_params(params)
+      end
     end
 
     def create
+      enforce_permission_to :create, :amendment, current_component: amendable.component
+
       @form = form(Decidim::Amendable::CreateForm).from_params(params)
-      enforce_permission_to :create, :amendment
 
-      Decidim::Amendable::Create.call(@form) do
-        on(:ok) do
+      Decidim::Amendable::CreateDraft.call(@form) do
+        on(:ok) do |amendment|
           flash[:notice] = t("created.success", scope: "decidim.amendments")
-          redirect_to Decidim::ResourceLocatorPresenter.new(@amendable).path
+          redirect_to compare_draft_amend_path(amendment)
         end
 
         on(:invalid) do
-          flash[:alert] = t("created.error", scope: "decidim.amendments")
+          flash.now[:alert] = t("created.error", scope: "decidim.amendments")
           render :new
         end
       end
     end
 
+    def compare_draft
+      enforce_permission_to :create, :amendment, current_component: amendable.component
+
+      if similar_emendations.empty?
+        flash[:notice] = t("no_similars_found", scope: "decidim.amendments.compare_draft")
+        redirect_to edit_draft_amend_path(amendment)
+      end
+    end
+
+    def edit_draft
+      enforce_permission_to :create, :amendment, current_component: amendable.component
+
+      @form = form(Decidim::Amendable::EditForm).from_model(amendment)
+    end
+
+    def update_draft
+      enforce_permission_to :create, :amendment, current_component: amendable.component
+
+      @form = form(Decidim::Amendable::EditForm).from_params(params)
+
+      Decidim::Amendable::UpdateDraft.call(@form) do
+        on(:ok) do |amendment|
+          flash[:notice] = t("success", scope: "decidim.amendments.update_draft")
+          redirect_to preview_draft_amend_path(amendment)
+        end
+
+        on(:invalid) do
+          flash.now[:alert] = t("error", scope: "decidim.amendments.update_draft")
+          render :edit_draft
+        end
+      end
+    end
+
+    def destroy_draft
+      enforce_permission_to :create, :amendment, current_component: amendable.component
+
+      Decidim::Amendable::DestroyDraft.call(amendment, current_user) do
+        on(:ok) do |amendable|
+          flash[:notice] = t("success", scope: "decidim.amendments.destroy_draft")
+          redirect_to new_amend_path(amendable_gid: amendable.to_sgid.to_s)
+        end
+
+        on(:invalid) do
+          flash[:alert] = t("error", scope: "decidim.amendments.destroy_draft")
+          redirect_to edit_draft_amend_path(amendment)
+        end
+      end
+    end
+
+    def preview_draft
+      enforce_permission_to :create, :amendment, current_component: amendable.component
+    end
+
+    def publish_draft
+      enforce_permission_to :create, :amendment, current_component: amendable.component
+
+      @form = form(Decidim::Amendable::PublishForm).from_model(amendment)
+
+      Decidim::Amendable::PublishDraft.call(@form) do
+        on(:ok) do |emendation|
+          flash[:notice] = t("success", scope: "decidim.amendments.publish_draft")
+          redirect_to Decidim::ResourceLocatorPresenter.new(emendation).path
+        end
+
+        on(:invalid) do
+          flash.now[:alert] = t("error", scope: "decidim.amendments.publish_draft")
+          render :edit_draft
+        end
+      end
+    end
+
     def reject
-      @form = form(Decidim::Amendable::RejectForm).from_params(params)
-      enforce_permission_to :reject, :amendment, amendment: @form.amendable
+      enforce_permission_to :reject, :amendment, current_component: amendable.component
+
+      @form = form(Decidim::Amendable::RejectForm).from_model(amendment)
 
       Decidim::Amendable::Reject.call(@form) do
         on(:ok) do
@@ -41,64 +126,99 @@ module Decidim
         on(:invalid) do
           flash[:alert] = t("rejected.error", scope: "decidim.amendments")
         end
-        redirect_to Decidim::ResourceLocatorPresenter.new(@emendation).path
+
+        redirect_to Decidim::ResourceLocatorPresenter.new(emendation).path
       end
     end
 
     def promote
-      @form = Decidim::Amendable::PromoteForm.from_params(params)
-      enforce_permission_to :promote, :amendment, amendment: @form.emendation
+      enforce_permission_to :promote, :amendment, current_component: amendable.component
+
+      @form = form(Decidim::Amendable::PromoteForm).from_model(amendment)
 
       Decidim::Amendable::Promote.call(@form) do
-        on(:ok) do |proposal|
+        on(:ok) do |promoted_resource|
           flash[:notice] = I18n.t("promoted.success", scope: "decidim.amendments")
-          redirect_to Decidim::ResourceLocatorPresenter.new(proposal).path
+          redirect_to Decidim::ResourceLocatorPresenter.new(promoted_resource).path
         end
 
         on(:invalid) do
           flash.now[:alert] = t("promoted.error", scope: "decidim.amendments")
-          redirect_to Decidim::ResourceLocatorPresenter.new(@emendation).path
+          redirect_to Decidim::ResourceLocatorPresenter.new(emendation).path
         end
       end
     end
 
     def review
-      @form = Decidim::Amendable::ReviewForm.from_params(params)
+      enforce_permission_to :accept, :amendment, current_component: amendable.component
+
+      @form = form(Decidim::Amendable::ReviewForm).from_params(params)
     end
 
     def accept
-      @form = Decidim::Amendable::ReviewForm.from_params(params)
-      enforce_permission_to :accept, :amendment, amendment: @form.amendable
+      enforce_permission_to :accept, :amendment, current_component: amendable.component
+
+      @form = form(Decidim::Amendable::ReviewForm).from_params(params)
 
       Decidim::Amendable::Accept.call(@form) do
-        on(:ok) do
+        on(:ok) do |emendation|
           flash[:notice] = t("accepted.success", scope: "decidim.amendments")
-          redirect_to Decidim::ResourceLocatorPresenter.new(@emendation).path
+          redirect_to Decidim::ResourceLocatorPresenter.new(emendation).path
         end
 
         on(:invalid) do
-          flash[:alert] = t("accepted.error", scope: "decidim.amendments")
+          flash.now[:alert] = t("accepted.error", scope: "decidim.amendments")
           render :review
         end
       end
     end
 
+    def withdraw
+      enforce_permission_to :withdraw, :amendment, amendment: amendment, current_component: amendable.component
+
+      Decidim::Amendable::Withdraw.call(amendment, current_user) do
+        on(:ok) do |withdrawn_emendation|
+          flash[:notice] = t("success", scope: "decidim.amendments.withdraw")
+          redirect_to Decidim::ResourceLocatorPresenter.new(withdrawn_emendation).path
+        end
+
+        on(:invalid) do
+          flash[:alert] = t("error", scope: "decidim.amendments.withdraw")
+          redirect_to Decidim::ResourceLocatorPresenter.new(emendation).path
+        end
+      end
+    end
+
     private
 
+    # GlobalID::SignedGlobalID parameter to locate the amendable resource.
+    # Needed for actions :new and :create, when there is no amendment yet.
     def amendable_gid
-      params[:amendable_gid] || params[:amendment][:amendable_gid]
+      params[:amendable_gid] || params.dig(:amendment, :amendable_gid)
+    end
+
+    def amendment
+      @amendment ||= Decidim::Amendment.find_by(id: params[:id])
     end
 
     def amendable
-      @amendable ||= if amendable_gid
-                       present(GlobalID::Locator.locate_signed(amendable_gid))
-                     else
-                       Decidim::Amendment.find_by(decidim_emendation_id: params[:id]).amendable
-                     end
+      @amendable ||= GlobalID::Locator.locate_signed(amendable_gid) || amendment&.amendable
     end
 
     def emendation
-      @emendation ||= present(Decidim::Amendment.find(params[:id]).emendation)
+      @emendation ||= amendment&.emendation
+    end
+
+    def amender
+      @amender ||= amendment&.amender
+    end
+
+    def ensure_is_draft_from_user
+      raise ActionController::RoutingError, "Not Found" unless amendment.draft? && amender == current_user
+    end
+
+    def similar_emendations
+      @similar_emendations ||= Decidim::SimilarEmendations.for(amendment)
     end
   end
 end