decidim-plans 0.15.0

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module Admin
+      # This controller allows admins to manage plans in a participatory process.
+      class SectionsController < Admin::ApplicationController
+        include Decidim::ApplicationHelper
+
+        helper Plans::ApplicationHelper
+
+        helper_method :blank_section, :section_types
+
+        def index
+          enforce_permission_to :create, :sections
+          @form = form(Admin::PlanSectionsForm).from_model(sections)
+        end
+
+        def new
+          enforce_permission_to :create, :sections
+          # TODO
+        end
+
+        def create
+          enforce_permission_to :create, :section
+          @form = form(Admin::PlanSectionsForm).from_params(params)
+
+          Admin::UpdateSections.call(@form, sections) do
+            on(:ok) do
+              flash[:notice] = I18n.t("update.success", scope: i18n_flashes_scope)
+              redirect_to sections_url
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("update.invalid", scope: i18n_flashes_scope)
+              render template: "index"
+            end
+          end
+        end
+
+        def edit
+          enforce_permission_to :edit, :section, section: section
+        end
+
+        def update
+          enforce_permission_to :edit, :section, section: section
+        end
+
+        private
+
+        def i18n_flashes_scope
+          "decidim.plans.admin.sections"
+        end
+
+        def sections
+          @sections ||= Section.where(component: current_component).order(:position)
+        end
+
+        def section
+          @section ||= Section.where(component: current_component).find(params[:id])
+        end
+
+        def blank_section
+          @blank_section ||= Admin::SectionForm.new
+        end
+
+        def section_types
+          @section_types ||= Section::TYPES.map do |section_type|
+            [I18n.t("decidim.plans.section_types.#{section_type}"), section_type]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # This controller is the abstract class from which all other controllers of
+    # this engine inherit.
+    #
+    # Note that it inherits from `Decidim::Components::BaseController`, which
+    # override its layout and provide all kinds of useful methods.
+    class ApplicationController < Decidim::Components::BaseController
+      helper Decidim::Messaging::ConversationHelper
+      helper_method :plan_limit_reached?
+
+      def plan_limit
+        return nil if component_settings.plan_limit.zero?
+        component_settings.plan_limit
+      end
+
+      def plan_limit_reached?
+        return false unless plan_limit
+
+        plans.where(author: current_user).count >= plan_limit
+      end
+
+      def plans
+        Plan.where(component: current_component)
+      end
+    end
+  end
+end

data/app/controllers/decidim/plans/plan_collaborator_requests_controller.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # Exposes Plan Request actions for collaboration between
+    # participants on a resource.
+    class PlanCollaboratorRequestsController < Decidim::Plans::PlansController
+      before_action :retrieve_plan, only: [:request_access, :request_accept, :request_reject]
+
+      def request_access
+        @request_access_form = form(RequestAccessToPlanForm).from_params(params)
+        RequestAccessToPlan.call(@request_access_form, current_user) do
+          on(:ok) do |_plan|
+            flash[:notice] = t("access_requested.success", scope: "decidim.plans.requests")
+          end
+
+          on(:invalid) do
+            flash[:alert] = t("access_requested.error", scope: "decidim.plans.requests")
+          end
+        end
+        redirect_to Decidim::ResourceLocatorPresenter.new(@plan).path
+      end
+
+      def request_accept
+        @accept_request_form = form(AcceptAccessToPlanForm).from_params(params)
+        AcceptAccessToPlan.call(@accept_request_form, current_user) do
+          on(:ok) do |requester_user|
+            flash[:notice] = t("accepted_request.success", scope: "decidim.plans.requests", user: requester_user.nickname)
+          end
+
+          on(:invalid) do
+            flash[:alert] = t("accepted_request.error", scope: "decidim.plans.requests")
+          end
+        end
+        redirect_to Decidim::ResourceLocatorPresenter.new(@plan).path
+      end
+
+      def request_reject
+        @reject_request_form = form(RejectAccessToPlanForm).from_params(params)
+        RejectAccessToPlan.call(@reject_request_form, current_user) do
+          on(:ok) do |requester_user|
+            flash[:notice] = t("rejected_request.success", scope: "decidim.plans.requests", user: requester_user.nickname)
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = t("rejected_request.error", scope: "decidim.plans.requests")
+          end
+        end
+        redirect_to Decidim::ResourceLocatorPresenter.new(@plan).path
+      end
+    end
+  end
+end

data/app/controllers/decidim/plans/plan_widgets_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    class PlanWidgetsController < Decidim::WidgetsController
+      helper Plans::ApplicationHelper
+
+      private
+
+      def model
+        @model ||= Plan.where(component: params[:component_id]).find(params[:plan_id])
+      end
+
+      def iframe_url
+        @iframe_url ||= plan_plan_widget_url(model)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # Exposes the plan resource so users can view and create them.
+    class PlansController < Decidim::Plans::ApplicationController
+      helper Decidim::WidgetUrlsHelper
+      helper UserGroupHelper
+      helper TooltipHelper
+      helper Plans::AttachmentsHelper
+      helper Plans::RemainingCharactersHelper
+      include AttachedProposalsHelper
+      include FormFactory
+      include FilterResource
+      include Orderable
+      include Paginable
+
+      helper_method :attached_proposals_picker_field
+
+      before_action :authenticate_user!, only: [:new, :create, :edit, :update, :withdraw, :preview, :publish, :destroy]
+      before_action :check_draft, only: [:new]
+      before_action :retrieve_plan, only: [:show, :edit, :update, :withdraw, :preview, :publish, :destroy]
+      before_action :ensure_published!, only: [:show, :withdraw]
+
+      def index
+        @plans = search
+                 .results
+                 .published
+                 .not_hidden
+                 .includes(:category)
+                 .includes(:scope)
+
+        @plans = paginate(@plans)
+        @plans = reorder(@plans)
+      end
+
+      def show
+        @report_form = form(Decidim::ReportForm).from_params(reason: "spam")
+        @request_access_form = form(RequestAccessToPlanForm).from_params({})
+        @accept_request_form = form(AcceptAccessToPlanForm).from_params({})
+        @reject_request_form = form(RejectAccessToPlanForm).from_params({})
+      end
+
+      def new
+        enforce_permission_to :create, :plan
+
+        @form = form(PlanForm).from_model(Plan.new(component: current_component))
+      end
+
+      def create
+        enforce_permission_to :create, :plan
+
+        @form = form(PlanForm).from_params(params, component: current_component)
+
+        CreatePlan.call(@form, current_user) do
+          on(:ok) do |plan|
+            flash[:notice] = I18n.t("plans.plans.create.success", scope: "decidim")
+            redirect_to Decidim::ResourceLocatorPresenter.new(plan).path + "/preview"
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("plans.plans.create.error", scope: "decidim")
+            render :new
+          end
+        end
+      end
+
+      def edit
+        enforce_permission_to :edit, :plan, plan: @plan
+
+        @form = form(PlanForm).from_model(@plan)
+      end
+
+      def update
+        enforce_permission_to :edit, :plan, plan: @plan
+
+        @form = form(PlanForm).from_params(params, compontent: current_component)
+        UpdatePlan.call(@form, current_user, @plan) do
+          on(:ok) do |plan|
+            flash[:notice] = I18n.t("plans.plans.update.success", scope: "decidim")
+
+            return redirect_to Decidim::ResourceLocatorPresenter.new(plan).path if plan.published?
+
+            redirect_to Decidim::ResourceLocatorPresenter.new(plan).path + "/preview"
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("plans.plans.update.error", scope: "decidim")
+            render :edit
+          end
+        end
+      end
+
+      def destroy
+        enforce_permission_to :edit, :plan, plan: @plan
+
+        # Form needed in case destroing fails
+        @form = form(PlanForm).from_model(@plan)
+
+        DestroyPlan.call(@plan, current_user) do
+          on(:ok) do
+            flash[:notice] = I18n.t("plans.plans.destroy.success", scope: "decidim")
+            redirect_to new_plan_path
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("plans.plans.destroy.error", scope: "decidim")
+            render :edit
+          end
+        end
+      end
+
+      def withdraw
+        raise ActionController::RoutingError, "Not Found" if @plan.withdrawn?
+        enforce_permission_to :withdraw, :plan, plan: @plan
+
+        WithdrawPlan.call(@plan, current_user) do
+          on(:ok) do
+            flash[:notice] = t("withdraw.success", scope: "decidim.plans.plans")
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = t("withdraw.error", scope: "decidim.plans.plans")
+          end
+        end
+        redirect_to Decidim::ResourceLocatorPresenter.new(@plan).path
+      end
+
+      def preview; end
+
+      def publish
+        PublishPlan.call(@plan, current_user) do
+          on(:ok) do |plan|
+            flash[:notice] = I18n.t("publish.success", scope: "decidim.plans.plans.plan")
+            redirect_to Decidim::ResourceLocatorPresenter.new(plan).path
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = t("publish.error", scope: "decidim.plans.plans.plan")
+            redirect_to Decidim::ResourceLocatorPresenter.new(@plan).path
+          end
+        end
+      end
+
+      private
+
+      def check_draft
+        redirect_to edit_plan_path(plan_draft) if plan_draft.present?
+      end
+
+      def plan_draft
+        Plan.drafts.from_all_author_identities(current_user).not_hidden.where(component: current_component)
+      end
+
+      def retrieve_plan
+        @plan = Plan.where(component: current_component).find(params[:id])
+      end
+
+      def ensure_published!
+        return unless @plan
+        return if @plan.published?
+
+        raise ActionController::RoutingError, "Not Found" unless @plan.editable_by?(current_user)
+
+        redirect_to preview_plan_path(@plan)
+      end
+
+      def search_klass
+        PlanSearch
+      end
+
+      def default_filter_params
+        {
+          search_text: "",
+          origin: "all",
+          activity: "",
+          category_id: "",
+          state: "except_rejected",
+          scope_id: nil,
+          related_to: ""
+        }
+      end
+
+      def context_params
+        {
+          component: current_component,
+          organization: current_organization
+        }
+      end
+    end
+  end
+end

data/app/controllers/decidim/plans/versions_controller.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # Exposes Plan versions so users can see how a Plan
+    # has been updated through time.
+    class VersionsController < Decidim::Plans::ApplicationController
+      helper Decidim::Plans::TraceabilityHelper
+      helper_method :current_version, :item_versions, :associated_versions,
+                    :content_versions, :item
+
+      private
+
+      def item
+        @item ||= Plan.where(component: current_component).find(params[:plan_id])
+      end
+
+      def current_version
+        return nil if params[:id].to_i < 1
+        @current_version ||= item.versions[params[:id].to_i - 1]
+      end
+
+      def item_versions
+        # There may be multiple updates on the item during the same transaction
+        Decidim::Plans::PaperTrail::Version.where(
+          transaction_id: current_version.transaction_id,
+          item_type: "Decidim::Plans::Plan"
+        ).order(:created_at)
+      end
+
+      def associated_versions
+        @associated_versions ||= Decidim::Plans::PaperTrail::Version.where(
+          transaction_id: current_version.transaction_id
+        ).where.not(
+          item_type: ["Decidim::Plans::Plan", "Decidim::Plans::Content"]
+        )
+      end
+
+      def content_versions
+        @content_versions ||= item.sections.map do |section|
+          content = item.contents.find_by(section: section)
+          next unless content
+
+          content.versions.find_by(
+            transaction_id: current_version.transaction_id
+          )
+        end.compact
+      end
+    end
+  end
+end

data/app/events/decidim/plans/accepted_plan_event.rb

@@ -0,0 +1,9 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Plans
+    class AcceptedPlanEvent < Decidim::Events::SimpleEvent
+      include Decidim::Events::AuthorEvent
+    end
+  end
+end

data/app/events/decidim/plans/evaluating_plan_event.rb

@@ -0,0 +1,8 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Plans
+    class EvaluatingPlanEvent < Decidim::Events::SimpleEvent
+    end
+  end
+end

data/app/events/decidim/plans/plan_access_accepted_event.rb

@@ -0,0 +1,8 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Plans
+    class PlanAccessAcceptedEvent < PlanAccessRequestEvent
+    end
+  end
+end

data/app/events/decidim/plans/plan_access_rejected_event.rb

@@ -0,0 +1,8 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Plans
+    class PlanAccessRejectedEvent < PlanAccessRequestEvent
+    end
+  end
+end

data/app/events/decidim/plans/plan_access_request_event.rb

@@ -0,0 +1,27 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Plans
+    class PlanAccessRequestEvent < Decidim::Events::SimpleEvent
+      i18n_attributes :requester_name, :requester_path, :requester_nickname
+
+      delegate :name, to: :requester, prefix: true
+
+      delegate :nickname, to: :requester, prefix: true
+
+      def requester_path
+        requester.profile_path
+      end
+
+      private
+
+      def requester
+        @requester ||= Decidim::UserPresenter.new(rejected_requester_user)
+      end
+
+      def rejected_requester_user
+        @rejected_requester_user ||= Decidim::User.find_by(id: extra[:requester_id])
+      end
+    end
+  end
+end

data/app/events/decidim/plans/plan_access_requested_event.rb

@@ -0,0 +1,8 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Plans
+    class PlanAccessRequestedEvent < PlanAccessRequestEvent
+    end
+  end
+end

data/app/events/decidim/plans/plan_access_requester_accepted_event.rb

@@ -0,0 +1,8 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Plans
+    class PlanAccessRequesterAcceptedEvent < Decidim::Events::SimpleEvent
+    end
+  end
+end

data/app/events/decidim/plans/plan_access_requester_rejected_event.rb

@@ -0,0 +1,8 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Plans
+    class PlanAccessRequesterRejectedEvent < Decidim::Events::SimpleEvent
+    end
+  end
+end

data/app/events/decidim/plans/publish_plan_event.rb

@@ -0,0 +1,25 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Plans
+    class PublishPlanEvent < Decidim::Events::SimpleEvent
+      include Decidim::Events::CoauthorEvent
+
+      def resource_text
+        # TODO
+      end
+
+      private
+
+      def i18n_scope
+        return super unless participatory_space_event?
+
+        "decidim.events.plans.plan_published_for_space"
+      end
+
+      def participatory_space_event?
+        extra.dig(:participatory_space)
+      end
+    end
+  end
+end

data/app/events/decidim/plans/rejected_plan_event.rb

@@ -0,0 +1,9 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Plans
+    class RejectedPlanEvent < Decidim::Events::SimpleEvent
+      include Decidim::Events::AuthorEvent
+    end
+  end
+end

data/app/forms/decidim/plans/accept_access_to_plan_form.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A form object to be used when Plan editors accept a request to
+    # access it as coauthors.
+    class AcceptAccessToPlanForm < AccessToPlanForm
+    end
+  end
+end

data/app/forms/decidim/plans/access_to_plan_form.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A form object common to accept and reject actions requesters of Plans.
+    class AccessToPlanForm < Decidim::Form
+      mimic :plan
+
+      attribute :id, String
+      attribute :requester_user_id, String
+      attribute :state, String
+
+      validates :id, :requester_user_id, presence: true
+      validates :state, presence: true, inclusion: { in: %w(open) }
+
+      validate :existence_of_requester_in_requesters
+
+      def plan
+        @plan ||= Decidim::Plans::Plan.find id if id
+      end
+
+      def requester_user
+        @requester_user ||= Decidim::User.find_by(id: requester_user_id, organization: current_organization) if requester_user_id
+      end
+
+      private
+
+      def existence_of_requester_in_requesters
+        if plan
+          errors.add(:requester_user_id, :invalid) unless plan.requesters.exists? requester_user_id
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/plans/admin/plan_answer_form.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module Admin
+      # A form object to be used when admin users want to answer a plan.
+      class PlanAnswerForm < Decidim::Form
+        include TranslatableAttributes
+        mimic :plan_answer
+
+        translatable_attribute :answer, String
+        attribute :state, String
+
+        validates :state, presence: true, inclusion: { in: %w(accepted rejected evaluating) }
+        validates :answer, translatable_presence: true, if: ->(form) { form.state == "rejected" }
+      end
+    end
+  end
+end