decidim-plans 0.15.0

data/app/cells/decidim/plans/plan_activity_cell.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A cell to display when a plan has been published.
+    class PlanActivityCell < ActivityCell
+      def title
+        I18n.t(
+          "decidim.plans.last_activity.new_plan_at_html",
+          link: participatory_space_link
+        )
+      end
+
+      def resource_link_text
+        Decidim::Plans::PlanPresenter.new(resource).title
+      end
+    end
+  end
+end

data/app/cells/decidim/plans/plan_cell.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "cell/partial"
+
+module Decidim
+  module Plans
+    # This cell renders the plan card for an instance of a Plan
+    # the default size is the Medium Card (:m)
+    class PlanCell < Decidim::ViewModel
+      include PlanCellsHelper
+      include Cell::ViewModel::Partial
+      include Messaging::ConversationHelper
+
+      delegate :user_signed_in?, to: :parent_controller
+
+      def show
+        cell card_size, model, options
+      end
+
+      private
+
+      def current_user
+        context[:current_user]
+      end
+
+      def card_size
+        "decidim/plans/plan_m"
+      end
+
+      def resource_path
+        resource_locator(model).path
+      end
+
+      def current_participatory_space
+        model.component.participatory_space
+      end
+
+      def current_component
+        model.component
+      end
+
+      def component_name
+        translated_attribute model.component.name
+      end
+
+      def component_type_name
+        model.class.model_name.human
+      end
+
+      def participatory_space_name
+        translated_attribute current_participatory_space.title
+      end
+
+      def participatory_space_type_name
+        translated_attribute current_participatory_space.model_name.human
+      end
+    end
+  end
+end

data/app/cells/decidim/plans/plan_m/footer.erb

@@ -0,0 +1,8 @@
+<div class="card__footer">
+  <div class="card__support">
+    <div class="card__support__data"></div>
+    <% if has_link_to_resource? %>
+      <%= link_to t("decidim.plans.plans.plan.view_plan"), resource_path, class: "card__button button--sc light button small secondary" %>
+    <% end %>
+  </div>
+</div>

data/app/cells/decidim/plans/plan_m_cell.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "cell/partial"
+
+module Decidim
+  module Plans
+    # This cell renders a plan with its M-size card.
+    class PlanMCell < Decidim::CardMCell
+      include PlanCellsHelper
+
+      def badge
+        render if has_badge?
+      end
+
+      private
+
+      def title
+        present(model).title
+      end
+
+      def body
+        present(model).body
+      end
+
+      def has_state?
+        model.published?
+      end
+
+      def has_badge?
+        answered? || withdrawn?
+      end
+
+      def has_link_to_resource?
+        model.published?
+      end
+
+      def description
+        model_body = strip_tags(body)
+
+        if options[:full_description]
+          model_body.gsub(/\n/, "<br>")
+        else
+          truncate(model_body, length: 100)
+        end
+      end
+
+      def badge_classes
+        return super unless options[:full_badge]
+
+        state_classes.concat(["label", "plan-status"]).join(" ")
+      end
+
+      def statuses
+        [:creation_date, :follow, :comments_count]
+      end
+
+      def creation_date_status
+        l(model.published_at.to_date, format: :decidim_short)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A command with all the business logic to accept a user request to
+    # contribute to a plan.
+    class AcceptAccessToPlan < 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?
+
+        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 recipient_ids
+        @plan.authors.pluck(:id) - [@requester_user.id]
+      end
+
+      def authors_event
+        "decidim.events.plans.plan_access_accepted"
+      end
+
+      def authors_event_class
+        Decidim::Plans::PlanAccessAcceptedEvent
+      end
+
+      def requester_event
+        "decidim.events.plans.plan_access_requester_accepted"
+      end
+
+      def requester_event_class
+        Decidim::Plans::PlanAccessRequesterAcceptedEvent
+      end
+    end
+  end
+end

data/app/commands/decidim/plans/admin/answer_plan.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module Admin
+      # A command with all the business logic when an admin answers a plan.
+      class AnswerPlan < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        # plan - The plan to write the answer for.
+        def initialize(form, plan)
+          @form = form
+          @plan = plan
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if form.invalid?
+
+          answer_plan
+          notify_followers
+
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :form, :plan
+
+        def answer_plan
+          Decidim.traceability.perform_action!(
+            "answer",
+            plan,
+            form.current_user
+          ) do
+            plan.update!(
+              state: @form.state,
+              answer: @form.answer,
+              answered_at: Time.current
+            )
+          end
+        end
+
+        def notify_followers
+          return if (plan.previous_changes.keys & %w(state)).empty?
+
+          if plan.accepted?
+            publish_event(
+              "decidim.events.plans.plan_accepted",
+              Decidim::Plans::AcceptedPlanEvent
+            )
+          elsif plan.rejected?
+            publish_event(
+              "decidim.events.plans.plan_rejected",
+              Decidim::Plans::RejectedPlanEvent
+            )
+          elsif plan.evaluating?
+            publish_event(
+              "decidim.events.plans.plan_evaluating",
+              Decidim::Plans::EvaluatingPlanEvent
+            )
+          end
+        end
+
+        def publish_event(event, event_class)
+          Decidim::EventsManager.publish(
+            event: event,
+            event_class: event_class,
+            resource: plan,
+            recipient_ids: plan.followers.pluck(:id)
+          )
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/plans/admin/create_plan.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module Admin
+      # A command with all the business logic when a user creates a new plan.
+      class CreatePlan < Rectify::Command
+        include AttachmentMethods
+
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(form)
+          @form = form
+        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
+          if process_attachments?
+            return broadcast(:invalid) if attachments_invalid?
+          end
+
+          if form.invalid?
+            mark_attachment_reattachment
+            return broadcast(:invalid)
+          end
+
+          Decidim::Plans.tracer.trace!(@form.current_user) do
+            transaction do
+              create_plan
+              create_plan_contents
+              update_attachments if process_attachments?
+              send_notification
+            end
+          end
+
+          broadcast(:ok, plan)
+        end
+
+        private
+
+        attr_reader :form, :plan, :attachment
+
+        def create_plan
+          @plan = Decidim::Plans.loggability.perform_action!(
+            :create,
+            Plan,
+            @form.current_user
+          ) do
+            plan = Plan.new(
+              { published_at: Time.current }.merge(attributes)
+            )
+            plan.coauthorships.build(author: form.author)
+            plan.save!
+            plan.proposals << form.proposals
+            plan
+          end
+
+          @attached_to = @plan
+        end
+
+        def create_plan_contents
+          @form.contents.each do |content|
+            @plan.contents.create!(
+              body: content.body,
+              section: content.section,
+              user: form.current_user
+            )
+          end
+        end
+
+        def attributes
+          {
+            title: form.title,
+            category: form.category,
+            scope: form.scope,
+            component: form.component,
+            state: "open",
+            published_at: Time.current
+          }
+        end
+
+        def send_notification
+          Decidim::EventsManager.publish(
+            event: "decidim.events.plans.plan_published",
+            event_class: Decidim::Plans::PublishPlanEvent,
+            resource: plan,
+            recipient_ids: @plan.participatory_space.followers.pluck(:id),
+            extra: {
+              participatory_space: true
+            }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module Admin
+      # 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.
+        # plan         - the plan to update.
+        def initialize(form, plan)
+          @form = form
+          @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) if form.invalid?
+
+          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!(form.current_user) do
+            transaction do
+              update_plan
+              update_plan_contents
+              update_plan_author
+              update_attachments if process_attachments?
+            end
+          end
+
+          broadcast(:ok, plan)
+        end
+
+        private
+
+        attr_reader :form, :plan, :attachment
+
+        def update_plan
+          Decidim::Plans.loggability.update!(
+            plan,
+            form.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 update_plan_author
+          plan.coauthorships.clear
+          plan.add_coauthor(form.author)
+          plan.save!
+          plan
+        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
+end

data/app/commands/decidim/plans/admin/update_sections.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module Admin
+      # This command is executed when the user modifies sections from
+      # the admin panel.
+      class UpdateSections < Rectify::Command
+        include NestedUpdater
+
+        # Initializes a UpdateSections Command.
+        #
+        # form - The form from which to get the data.
+        # sections - The current set of the sections to be updated.
+        def initialize(form, sections)
+          @form = form
+          @sections = sections
+        end
+
+        # Updates the sections if valid.
+        #
+        # Broadcasts :ok if successful, :invalid otherwise.
+        def call
+          return broadcast(:invalid) if @form.invalid?
+
+          Decidim::Plans::Section.transaction do
+            update_sections
+          end
+
+          broadcast(:ok)
+        end
+
+        private
+
+        def update_sections
+          @form.sections.each do |form_section|
+            update_nested_model(
+              form_section,
+              {
+                body: form_section.body,
+                help: form_section.help,
+                mandatory: form_section.mandatory,
+                answer_length: form_section.answer_length,
+                position: form_section.position,
+                section_type: form_section.section_type
+              },
+              @sections
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A module with all the attachment methods for plan commands.
+    module AttachmentMethods
+      include NestedUpdater
+
+      private
+
+      def prepare_attachments
+        @form.attachments.each do |atform|
+          next if atform.file.present? || atform.id.blank?
+
+          attachment = @plan.attachments.find_by(id: atform.id)
+          atform.file = attachment.file if attachment
+        end
+      end
+
+      def mark_attachment_reattachment
+        if @form.invalid? || @form.errors.any?
+          @form.attachments.each do |at|
+            at.errors.add(:file, :needs_to_be_reattached) if at.present? && at.id.blank?
+          end
+        end
+      end
+
+      def attachments_invalid?
+        @form.attachments.each do |atform|
+          next if atform.deleted?
+
+          attachment = Attachment.new(attachment_params(atform))
+
+          next if attachment.valid? || !attachment.errors.has_key?(:file)
+
+          atform.errors.add :file, attachment.errors[:file]
+        end
+
+        @form.attachments.any? { |at| at.errors.any? }
+      end
+
+      def attachments_present?
+        attachments_allowed? && @form.attachments.any? do |at|
+          at.title.present? || at.file.present? || at.id.present?
+        end
+      end
+
+      def update_attachments
+        @form.attachments.each do |attachment|
+          update_nested_model(
+            attachment,
+            attachment_params(attachment),
+            @plan.attachments
+          )
+        end
+      end
+
+      def attachments_allowed?
+        @form.current_component.settings.attachments_allowed?
+      end
+
+      def process_attachments?
+        attachments_allowed? && attachments_present?
+      end
+
+      def attachment_params(form)
+        params = {
+          weight: form.weight,
+          title: form.title,
+          attached_to: @attached_to
+        }
+        params[:file] = form.file if form.file.present?
+
+        params
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A command with all the business logic when a user creates a new plan.
+    class CreatePlan < Rectify::Command
+      include AttachmentMethods
+      # Public: Initializes the command.
+      #
+      # form         - A form object with the params.
+      # current_user - The current user.
+      def initialize(form, current_user)
+        @form = form
+        @current_user = current_user
+        @attached_to = nil
+      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
+        if process_attachments?
+          return broadcast(:invalid) if attachments_invalid?
+        end
+
+        if form.invalid?
+          mark_attachment_reattachment
+          return broadcast(:invalid)
+        end
+
+        Decidim::Plans.tracer.trace!(@form.current_user) do
+          transaction do
+            create_plan
+            create_plan_contents
+            update_attachments if process_attachments?
+          end
+        end
+
+        broadcast(:ok, plan)
+      end
+
+      private
+
+      attr_reader :form, :plan, :attachments
+
+      def create_plan
+        @plan = Decidim::Plans.loggability.perform_action!(
+          :create,
+          Plan,
+          @form.current_user
+        ) do
+          plan = Plan.new(
+            title: form.title,
+            category: form.category,
+            scope: form.scope,
+            component: form.component,
+            state: "open"
+          )
+          plan.coauthorships.build(author: @current_user, user_group: @form.user_group)
+          plan.save!
+          plan.proposals << form.proposals
+          plan
+        end
+
+        @attached_to = @plan
+      end
+
+      def create_plan_contents
+        @form.contents.each do |content|
+          @plan.contents.create!(
+            body: content.body,
+            section: content.section,
+            user: @current_user
+          )
+        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
+    end
+  end
+end