decidim-plans 0.15.0

data/app/commands/decidim/plans/destroy_plan.rb

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

data/app/commands/decidim/plans/nested_updater.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # Updater for nested models.
+    module NestedUpdater
+      private
+
+      def update_nested_model(form, attributes, parent_association)
+        record = parent_association.find_by(id: form.id) || parent_association.build(attributes)
+
+        yield record if block_given?
+
+        if record.persisted?
+          if form.deleted?
+            record.destroy!
+          else
+            record.update!(attributes)
+          end
+        elsif !form.deleted?
+          record.save!
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/plans/publish_plan.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A command with all the business logic when a user creates a new plan.
+    class PublishPlan < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # plan         - The plan to publish.
+      # current_user - The current user.
+      def initialize(plan, current_user)
+        @plan = plan
+        @current_user = current_user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid and the plan is published.
+      # - :invalid if the plan's author is not the current user.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless @plan.authored_by?(@current_user)
+
+        transaction do
+          publish_plan
+          send_notification
+          send_notification_to_participatory_space
+        end
+
+        broadcast(:ok, @plan)
+      end
+
+      private
+
+      def publish_plan
+        Decidim.traceability.perform_action!(
+          "publish",
+          @plan,
+          @current_user,
+          visibility: "public-only"
+        ) do
+          @plan.update published_at: Time.current
+        end
+      end
+
+      def send_notification
+        return if @plan.coauthorships.empty?
+
+        Decidim::EventsManager.publish(
+          event: "decidim.events.plans.plan_published",
+          event_class: Decidim::Plans::PublishPlanEvent,
+          resource: @plan,
+          recipient_ids: coauthors_followers
+        )
+      end
+
+      def send_notification_to_participatory_space
+        Decidim::EventsManager.publish(
+          event: "decidim.events.plans.plan_published",
+          event_class: Decidim::Plans::PublishPlanEvent,
+          resource: @plan,
+          recipient_ids: @plan.participatory_space.followers.pluck(:id) - coauthors_followers,
+          extra: {
+            participatory_space: true
+          }
+        )
+      end
+
+      def coauthors_followers
+        followers_ids = []
+        @plan.authors.each do |author|
+          followers_ids += author.followers.pluck(:id)
+        end
+        followers_ids
+      end
+    end
+  end
+end

data/app/commands/decidim/plans/reject_access_to_plan.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A command with all the business logic to reject a user request to
+    # contribute to a plan.
+    class RejectAccessToPlan < RespondToAccessRequest
+      # 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?
+
+        @plan.requesters.delete @requester_user
+
+        notify_plan_requester
+        notify_plan_authors
+        broadcast(:ok, @requester_user)
+      end
+
+      def recipient_ids
+        @plan.authors.pluck(:id)
+      end
+
+      def authors_event
+        "decidim.events.plans.plan_access_rejected"
+      end
+
+      def authors_event_class
+        Decidim::Plans::PlanAccessRejectedEvent
+      end
+
+      def requester_event
+        "decidim.events.plans.plan_access_requester_rejected"
+      end
+
+      def requester_event_class
+        Decidim::Plans::PlanAccessRequesterRejectedEvent
+      end
+    end
+  end
+end

data/app/commands/decidim/plans/request_access_to_plan.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A command with all the business logic when a user requests
+    # access to edit a plan.
+    class RequestAccessToPlan < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # form         - A form object with the params.
+      # plan     - A Decidim::Plans::Plan object.
+      # current_user - The current user and requester user
+      def initialize(form, current_user)
+        @form = form
+        @plan = form.plan
+        @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?
+
+        @plan.collaborator_requests.create!(user: @current_user)
+        notify_plan_authors
+        broadcast(:ok, @plan)
+      end
+
+      private
+
+      def notify_plan_authors
+        recipient_ids = @plan.authors.pluck(:id)
+        Decidim::EventsManager.publish(
+          event: "decidim.events.plans.plan_access_requested",
+          event_class: Decidim::Plans::PlanAccessRequestedEvent,
+          resource: @plan,
+          recipient_ids: recipient_ids.uniq,
+          extra: {
+            requester_id: @current_user.id
+          }
+        )
+      end
+    end
+  end
+end

data/app/commands/decidim/plans/respond_to_access_request.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # Common functionality for {Accept,Reject}AccessToPlan.
+    class RespondToAccessRequest < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # form     - A form object with the params.
+      # plan     - A Decidim::Plans::Plan object.
+      # current_user - The current user.
+      # requester_user - The user that requested to collaborate.
+      def initialize(form, current_user)
+        @form = form
+        @plan = form.plan
+        @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?
+
+        transaction do
+          @plan.requesters.delete @requester_user
+
+          Decidim::Coauthorship.create(
+            coauthorable: @plan,
+            author: @requester_user
+          )
+        end
+
+        notify_plan_requester
+        notify_plan_authors
+        broadcast(:ok, @requester_user)
+      end
+
+      def notify_plan_authors
+        Decidim::EventsManager.publish(
+          event: authors_event,
+          event_class: authors_event_class,
+          resource: @plan,
+          recipient_ids: recipient_ids.uniq,
+          extra: {
+            requester_id: @requester_user.id
+          }
+        )
+      end
+
+      def notify_plan_requester
+        Decidim::EventsManager.publish(
+          event: requester_event,
+          event_class: requester_event_class,
+          resource: @plan,
+          recipient_ids: [@requester_user.id]
+        )
+      end
+
+      def recipient_ids; end
+
+      def authors_event; end
+
+      def authors_event_class; end
+
+      def requester_event; end
+
+      def requester_event_class; end
+    end
+  end
+end

data/app/commands/decidim/plans/update_plan.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A command with all the business logic when a user updates a plan.
+    class UpdatePlan < Rectify::Command
+      include AttachmentMethods
+      include NestedUpdater
+
+      # Public: Initializes the command.
+      #
+      # form         - A form object with the params.
+      # current_user - The current user.
+      # plan - the plan to update.
+      def initialize(form, current_user, plan)
+        @form = form
+        @current_user = current_user
+        @plan = plan
+        @attached_to = plan
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the plan.
+      # - :invalid if the form wasn't valid and we couldn't proceed.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless plan.editable_by?(current_user)
+
+        if process_attachments?
+          prepare_attachments
+          return broadcast(:invalid) if attachments_invalid?
+        end
+
+        if form.invalid?
+          mark_attachment_reattachment
+          return broadcast(:invalid)
+        end
+
+        Decidim::Plans.tracer.trace!(@current_user) do
+          transaction do
+            update_plan
+            update_plan_contents
+            update_attachments if process_attachments?
+          end
+        end
+
+        broadcast(:ok, plan)
+      end
+
+      private
+
+      attr_reader :form, :plan, :current_user, :attachments
+
+      def update_plan
+        Decidim::Plans.loggability.update!(
+          @plan,
+          @current_user,
+          attributes
+        )
+      end
+
+      def update_plan_contents
+        @form.contents.each do |content|
+          update_nested_model(
+            content,
+            { body: content.body,
+              section: content.section,
+              user: @form.current_user },
+            @plan.contents
+          )
+        end
+      end
+
+      def attributes
+        {
+          title: @form.title,
+          category: @form.category,
+          scope: @form.scope,
+          proposals: @form.proposals,
+          # The update token ensures a new version is always created even if
+          # the other attributes have not changed. This is needed to force a new
+          # version to show the changes to associated models.
+          update_token: Time.now.to_f
+        }
+      end
+    end
+  end
+end

data/app/commands/decidim/plans/withdraw_plan.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A command with all the business logic when a user withdraws a plan.
+    class WithdrawPlan < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # plan         - The plan to withdraw.
+      # current_user - The current user.
+      def initialize(plan, current_user)
+        @plan = plan
+        @current_user = current_user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the proposal.
+      # - :invalid if the proposal already has supports or does not belong to current user.
+      #
+      # Returns nothing.
+      def call
+        # return broadcast(:invalid) if @plan.votes.any?
+
+        transaction do
+          change_plan_state_to_withdrawn
+          # reject_emendations_if_any # 0.16+
+        end
+
+        broadcast(:ok, @plan)
+      end
+
+      private
+
+      def change_plan_state_to_withdrawn
+        @plan.update state: "withdrawn"
+      end
+
+      def reject_emendations_if_any
+        return if @plan.emendations.empty?
+
+        @plan.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/plans/orderable.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module Plans
+    # Common logic to ordering resources
+    module Orderable
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :order, :available_orders, :random_seed
+
+        private
+
+        # Gets how the plans should be ordered based on the choice made by the user.
+        def order
+          @order ||= detect_order(params[:order]) || default_order
+        end
+
+        # Available orders based on enabled settings
+        def available_orders
+          @available_orders ||= begin
+            available_orders = %w(random recent)
+            available_orders
+          end
+        end
+
+        def default_order
+          "random"
+        end
+
+        # Returns: A random float number between -1 and 1 to be used as a random seed at the database.
+        def random_seed
+          @random_seed ||= (params[:random_seed] ? params[:random_seed].to_f : (rand * 2 - 1))
+        end
+
+        def detect_order(candidate)
+          available_orders.detect { |order| order == candidate }
+        end
+
+        def reorder(plans)
+          case order
+          when "random"
+            plans.order_randomly(random_seed)
+          when "recent"
+            plans.order(created_at: :desc)
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/plans/admin/application_controller.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module Admin
+      # This controller is the abstract class from which all other controllers of
+      # this engine inherit.
+      #
+      # Note that it inherits from `Decidim::Admin::Components::BaseController`, which
+      # override its layout and provide all kinds of useful methods.
+      class ApplicationController < Decidim::Admin::Components::BaseController
+        helper Decidim::ApplicationHelper
+      end
+    end
+  end
+end

data/app/controllers/decidim/plans/admin/plan_answers_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module Admin
+      # This controller allows admins to answer plans in a participatory process.
+      class PlanAnswersController < Admin::ApplicationController
+        helper_method :plan
+
+        def edit
+          enforce_permission_to :create, :plan_answer
+          @form = form(Admin::PlanAnswerForm).from_model(plan)
+        end
+
+        def update
+          enforce_permission_to :create, :plan_answer
+          @form = form(Admin::PlanAnswerForm).from_params(params)
+
+          Admin::AnswerPlan.call(@form, plan) do
+            on(:ok) do
+              flash[:notice] = I18n.t("plans.answer.success", scope: "decidim.plans.admin")
+              redirect_to plans_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("plans.answer.invalid", scope: "decidim.plans.admin")
+              render action: "edit"
+            end
+          end
+        end
+
+        private
+
+        def plan
+          @plan ||= Plan.where(component: current_component).find(params[:id])
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/plans/admin/plans_controller.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module Admin
+      # This controller allows admins to manage plans in a participatory process.
+      class PlansController < Admin::ApplicationController
+        include Decidim::ApplicationHelper
+        include Plans::AttachedProposalsHelper
+
+        helper Plans::ApplicationHelper
+        helper Plans::AttachmentsHelper
+        helper Plans::RemainingCharactersHelper
+        helper_method :plans, :query, :form_presenter, :attached_proposals_picker_field
+
+        def new
+          enforce_permission_to :create, :plans
+          @form = form(Admin::PlanForm).from_model(Plan.new(component: current_component))
+        end
+
+        def create
+          enforce_permission_to :create, :plan
+          @form = form(Admin::PlanForm).from_params(params)
+
+          Admin::CreatePlan.call(@form) do
+            on(:ok) do
+              flash[:notice] = I18n.t("plans.create.success", scope: "decidim")
+              redirect_to plans_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("plans.create.invalid", scope: "decidim")
+              render action: "new"
+            end
+          end
+        end
+
+        def edit
+          enforce_permission_to :edit, :plan, plan: plan
+          @form = form(Admin::PlanForm).from_model(plan)
+        end
+
+        def update
+          enforce_permission_to :edit, :plan, plan: plan
+
+          @form = form(Admin::PlanForm).from_params(params)
+          Admin::UpdatePlan.call(@form, @plan) do
+            on(:ok) do
+              flash[:notice] = I18n.t("plans.update.success", scope: "decidim")
+              redirect_to plans_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("plans.update.invalid", scope: "decidim")
+              render :edit
+            end
+          end
+        end
+
+        private
+
+        def query
+          @query ||= Plan.where(component: current_component).ransack(params[:q])
+        end
+
+        def plans
+          @plans ||= query.result.page(params[:page]).per(15)
+        end
+
+        def plan
+          @plan ||= Plan.where(component: current_component).find(params[:id])
+        end
+
+        def form_presenter
+          @form_presenter ||= present(@form, presenter_class: Decidim::Plans::PlanPresenter)
+        end
+      end
+    end
+  end
+end