decidim-plans 0.15.0

data/app/presenters/decidim/plans/log/resource_presenter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module Log
+      class ResourcePresenter < Decidim::Log::ResourcePresenter
+        private
+
+        # Private: Presents resource name.
+        #
+        # Returns an HTML-safe String.
+        def present_resource_name
+          Decidim::Plans::PlanPresenter.new(resource).title if resource
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/plans/official_author_presenter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    #
+    # A dummy presenter to abstract out the author of an official plan.
+    #
+    class OfficialAuthorPresenter
+      def name
+        I18n.t("decidim.plans.models.plan.fields.official_plan")
+      end
+
+      def nickname
+        ""
+      end
+
+      def badge
+        ""
+      end
+
+      def profile_path
+        ""
+      end
+
+      def avatar_url
+        ActionController::Base.helpers.asset_path("decidim/default-avatar.svg")
+      end
+
+      def deleted?
+        false
+      end
+
+      def can_be_contacted?
+        false
+      end
+    end
+  end
+end

data/app/presenters/decidim/plans/plan_presenter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    #
+    # Decorator for plans
+    #
+    class PlanPresenter < SimpleDelegator
+      include Rails.application.routes.mounted_helpers
+      include ActionView::Helpers::UrlHelper
+      include TranslatableAttributes
+
+      def author
+        coauthorship = coauthorships.first
+        @author ||= if coauthorship.user_group
+                      Decidim::UserGroupPresenter.new(coauthorship.user_group)
+                    else
+                      Decidim::UserPresenter.new(coauthorship.author)
+                    end
+      end
+
+      def plan
+        __getobj__
+      end
+
+      def plan_path
+        Decidim::ResourceLocatorPresenter.new(plan).path
+      end
+
+      def title
+        translated_attribute(plan.title).html_safe
+      end
+
+      def body
+        fields = plan.sections.map do |section|
+          content = plan.contents.find_by(section: section)
+          next if content.nil?
+
+          title = translated_attribute(content.title)
+          body = translated_attribute(content.body)
+          "<dt>#{title}</dt> <dd>#{body}</dd>"
+        end
+
+        "<dl>#{fields.join("\n")}</dl>".html_safe
+      end
+    end
+  end
+end

data/app/queries/decidim/plans/filtered_plans.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A class used to find plans filtered by components and a date range
+    class FilteredPlans < Rectify::Query
+      # Syntactic sugar to initialize the class and return the queried objects.
+      #
+      # components - An array of Decidim::Component
+      # start_at - A date to filter resources created after it
+      # end_at - A date to filter resources created before it.
+      def self.for(components, start_at = nil, end_at = nil)
+        new(components, start_at, end_at).query
+      end
+
+      # Initializes the class.
+      #
+      # components - An array of Decidim::Component
+      # start_at - A date to filter resources created after it
+      # end_at - A date to filter resources created before it.
+      def initialize(components, start_at = nil, end_at = nil)
+        @components = components
+        @start_at = start_at
+        @end_at = end_at
+      end
+
+      # Finds the Plans scoped to an array of components and filtered
+      # by a range of dates.
+      def query
+        plans = Decidim::Plans::Plan.where(component: @components)
+        plans = plans.where("created_at >= ?", @start_at) if @start_at.present?
+        plans = plans.where("created_at <= ?", @end_at) if @end_at.present?
+        plans
+      end
+    end
+  end
+end

data/app/services/decidim/plans/diff_renderer/base.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module DiffRenderer
+      class Base
+        include ::Decidim::ApplicationHelper
+
+        def initialize(version, locale)
+          @version = version
+          @display_locale = locale
+        end
+
+        # Renders the diff of the given changeset. Doesn't take into account
+        # translatable fields.
+        #
+        # Returns a Hash, where keys are the fields that have changed and values
+        # are an array, the first element being the previous value and the last
+        # being the new one.
+        def diff
+          version.changeset.inject({}) do |diff, (attribute, values)|
+            attribute = attribute.to_sym
+            type = attribute_types[attribute]
+
+            if type.blank?
+              diff
+            elsif [:i18n, :i18n_html].include?(type)
+              parse_i18n_changeset(attribute, values, type, diff)
+            else
+              parse_changeset(attribute, values, type, diff)
+            end
+          end
+        end
+
+        protected
+
+        attr_reader :version, :display_locale
+
+        def i18n_scope
+          "activemodel.attributes"
+        end
+
+        def generate_label(attribute)
+          I18n.t(attribute, scope: i18n_scope)
+        end
+
+        def generate_i18n_label(attribute, locale)
+          label = I18n.t(attribute, scope: i18n_scope)
+          return label if display_locale
+          "#{label} (#{locale_name(locale)})"
+        end
+
+        def locale_name(locale)
+          if I18n.available_locales.include?(locale.to_sym)
+            I18n.t("locale.name", locale: locale)
+          else
+            locale
+          end
+        end
+
+        def translated_attribute(attribute, locale = nil)
+          return "" if attribute.nil?
+          return attribute unless attribute.is_a?(Hash)
+
+          attribute = attribute.dup.stringify_keys
+          locale ||= I18n.locale.to_s
+
+          attribute[locale].presence ||
+            attribute[I18n.locale.to_s].presence ||
+            attribute[attribute.keys.first].presence ||
+            ""
+        end
+
+        def parse_changeset(attribute, values, type, diff)
+          diff.update(
+            attribute => {
+              type: type,
+              label: generate_label(attribute),
+              old_value: values[0],
+              new_value: values[1]
+            }
+          )
+        end
+
+        def parse_i18n_changeset(attribute, values, type, diff)
+          values.last.each_key do |locale, _value|
+            next if display_locale && display_locale != locale
+
+            first_value = values.first.try(:[], locale) if values.first.is_a? Hash
+            last_value = values.last.try(:[], locale) if values.last.is_a? Hash
+            next if first_value == last_value
+
+            attribute_locale = "#{attribute}_#{locale}".to_sym
+            diff.update(
+              attribute_locale => {
+                type: :string,
+                label: generate_i18n_label(attribute, locale),
+                old_value: first_value,
+                new_value: last_value
+              }
+            )
+          end
+          diff
+        end
+      end
+    end
+  end
+end

data/app/services/decidim/plans/diff_renderer/categorization.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module DiffRenderer
+      class Categorization < Base
+        protected
+
+        def i18n_scope
+          "activemodel.attributes.plan"
+        end
+
+        # Lists which attributes will be diffable and how
+        # they should be rendered.
+        def attribute_types
+          {
+            decidim_category_id: :category
+          }
+        end
+      end
+    end
+  end
+end

data/app/services/decidim/plans/diff_renderer/content.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module DiffRenderer
+      class Content < Base
+        protected
+
+        def i18n_scope
+          "activemodel.attributes.plan"
+        end
+
+        # Lists which attributes will be diffable and how
+        # they should be rendered.
+        def attribute_types
+          {
+            body: :i18n
+          }
+        end
+
+        def generate_label(_attribute)
+          translated_attribute(version.item.section.body)
+        end
+
+        def generate_i18n_label(_attribute, locale)
+          label = translated_attribute(version.item.section.body, locale)
+          return label if display_locale
+          "#{label} (#{locale_name(locale)})"
+        end
+      end
+    end
+  end
+end

data/app/services/decidim/plans/diff_renderer/plan.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module DiffRenderer
+      class Plan < Base
+        protected
+
+        def i18n_scope
+          "activemodel.attributes.plan"
+        end
+
+        # Lists which attributes will be diffable and how
+        # they should be rendered.
+        def attribute_types
+          {
+            title: :i18n,
+            decidim_scope_id: :scope,
+            state: :string
+          }
+        end
+      end
+    end
+  end
+end

data/app/services/decidim/plans/loggability.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # The loggability class modifies the core's Traceability class by removing
+    # the PaperTrail tracing from the objects. This is needed because we want to
+    # handle the PaperTrail tracing manually for the plans.
+    class Loggability < ::Decidim::Traceability
+      def perform_action!(action, resource, author, extra_log_info = {})
+        Decidim::ApplicationRecord.transaction do
+          result = block_given? ? yield : nil
+          loggable_resource = resource.is_a?(Class) ? result : resource
+          log(action, author, loggable_resource, extra_log_info)
+          return result
+        end
+      end
+    end
+  end
+end

data/app/services/decidim/plans/plan_builder.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A factory class to ensure we always create Plans the same way since it involves some logic.
+    module PlanBuilder
+      # Public: Creates a new Plan.
+      #
+      # attributes        - The Hash of attributes to create the Plan with.
+      # author            - An Authorable the will be the first coauthor of the Plan.
+      # user_group_author - A User Group to, optionally, set it as the author too.
+      # action_user       - The User to be used as the user who is creating the plan in the traceability logs.
+      #
+      # Returns a Plan.
+      def create(attributes:, author:, action_user:, user_group_author: nil)
+        Decidim.traceability.perform_action!(:create, Plan, action_user, visibility: "all") do
+          plan = Plan.new(attributes)
+          plan.add_coauthor(author, user_group: user_group_author)
+          plan.save!
+          plan
+        end
+      end
+
+      module_function :create
+
+      # Public: Creates a new Plan by copying the attributes from another one.
+      #
+      # original_plan     - The Plan to be used as base to create the new one.
+      # author            - An Authorable the will be the first coauthor of the Plan.
+      # user_group_author - A User Group to, optionally, set it as the author too.
+      # action_user       - The User to be used as the user who is creating the plan in the traceability logs.
+      # extra_attributes  - A Hash of attributes to create the new plan, will overwrite the original ones.
+      # skip_link         - Whether to skip linking the two plans or not (default false).
+      #
+      # Returns a Plan
+      #
+      # rubocop:disable Metrics/ParameterLists
+      def copy(original_plan, author:, action_user:, user_group_author: nil, extra_attributes: {}, skip_link: false)
+        origin_attributes = original_plan.attributes.except(
+          "id",
+          "created_at",
+          "updated_at",
+          "state",
+          "answer",
+          "answered_at",
+          "decidim_component_id"
+        ).merge(
+          "category" => original_plan.category
+        ).merge(
+          extra_attributes
+        )
+
+        plan = create(
+          attributes: origin_attributes,
+          author: author,
+          user_group_author: user_group_author,
+          action_user: action_user
+        )
+
+        plan.link_resources(original_plan, "copied_from_component") unless skip_link
+        plan
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      module_function :copy
+    end
+  end
+end

data/app/services/decidim/plans/plan_search.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A service to encapsualte all the logic when searching and filtering
+    # plans in a participatory process.
+    class PlanSearch < ResourceSearch
+      # Public: Initializes the service.
+      # component   - A Decidim::Component to get the plans from.
+      # page        - The page number to paginate the results.
+      # per_page    - The number of plans to return per page.
+      def initialize(options = {})
+        super(Plan.all, options)
+      end
+
+      # Handle the search_text filter
+      def search_search_text
+        query.where(localized_search_text_in(:title), text: "%#{search_text}%")
+      end
+
+      # Handle the origin filter
+      # The 'official' plans doesn't have an author id
+      def search_origin
+        if origin == "official"
+          query.where.not(coauthorships_count: 0).joins(:coauthorships).where(decidim_coauthorships: { decidim_author_type: "Decidim::Organization" })
+        elsif origin == "citizens"
+          query.where.not(coauthorships_count: 0).joins(:coauthorships).where.not(decidim_coauthorships: { decidim_author_type: "Decidim::Organization" })
+        else # Assume 'all'
+          query
+        end
+      end
+
+      # Handle the activity filter
+      def search_activity
+        query
+      end
+
+      # Handle the state filter
+      def search_state
+        case state
+        when "accepted"
+          query.accepted
+        when "rejected"
+          query.rejected
+        when "evaluating"
+          query.evaluating
+        when "withdrawn"
+          query.withdrawn
+        when "except_rejected"
+          query.except_rejected.except_withdrawn
+        else # Assume 'not_withdrawn'
+          query.except_withdrawn
+        end
+      end
+
+      # Filters Plans by the name of the classes they are linked to. By default,
+      # returns all Plans. When a `related_to` param is given, then it camelcases item
+      # to find the real class name and checks the links for the Plans.
+      #
+      # The `related_to` param is expected to be in this form:
+      #
+      #   "decidim/meetings/meeting"
+      #
+      # This can be achieved by performing `klass.name.underscore`.
+      #
+      # Returns only those plans that are linked to the given class name.
+      def search_related_to
+        from = query
+               .joins(:resource_links_from)
+               .where(decidim_resource_links: { to_type: related_to.camelcase })
+
+        to = query
+             .joins(:resource_links_to)
+             .where(decidim_resource_links: { from_type: related_to.camelcase })
+
+        query.where(id: from).or(query.where(id: to))
+      end
+
+      private
+
+      # Internal: builds the needed query to search for a text in the organization's
+      # available locales. Note that it is intended to be used as follows:
+      #
+      # Example:
+      #   Resource.where(localized_search_text_for(:title, text: "my_query"))
+      #
+      # The Hash with the `:text` key is required or it won't work.
+      def localized_search_text_in(field)
+        options[:organization].available_locales.map do |l|
+          "#{field} ->> '#{l}' ILIKE :text"
+        end.join(" OR ")
+      end
+    end
+  end
+end

data/app/services/decidim/plans/tracer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # The Tracer class allows performing PaperTrail requests where all records
+    # saved during the yield will be stored against the same transaction ID.
+    # This allows saving the main record and its associated records so that the
+    # same changeset can be easily identified afterwards.
+    class Tracer
+      def trace!(author)
+        return unless block_given?
+
+        ::PaperTrail.request(whodunnit: gid(author)) do
+          yield
+        end
+      end
+
+      private
+
+      # Calculates the GlobalID of the version author. If the object does not
+      # respond to `to_gid`, then it returns the object itself.
+      def gid(author)
+        return if author.blank?
+        return author.to_gid if author.respond_to?(:to_gid)
+        author
+      end
+    end
+  end
+end

data/app/views/decidim/plans/admin/plan_answers/edit.html.erb

@@ -0,0 +1,22 @@
+<%= render "decidim/plans/admin/shared/info_plan" %>
+<%= decidim_form_for(@form, url: plan_plan_answer_path(plan, @form), html: { class: "form edit_plan_answer" }) do |f| %>
+  <div class="card">
+    <div class="card-divider">
+      <h2 class="card-title"><%= t ".title", title: present(plan).title %></h2>
+    </div>
+
+    <div class="card-section">
+      <div class="row column">
+        <%= f.collection_radio_buttons :state, [["accepted", t(".accepted")], ["rejected", t(".rejected")], ["evaluating", t(".evaluating")]], :first, :last, prompt: true %>
+      </div>
+
+      <div class="row column">
+        <%= f.translated :editor, :answer, autofocus: true, rows: 15 %>
+      </div>
+    </div>
+  </div>
+
+  <div class="button--double form-general-submit">
+    <%= f.submit t(".answer_plan") %>
+  </div>
+<% end %>

data/app/views/decidim/plans/admin/plans/_bulk-actions.html.erb

@@ -0,0 +1,9 @@
+<div class="flex--cc flex-gap--1">
+  <div id="js-other-actions-wrapper">
+    <%= link_to t("actions.sections", scope: "decidim.plans"), sections_path, class: "button tiny button--simple" %>
+
+    <% if allowed_to? :create, :plan %>
+      <%= link_to t("actions.new", scope: "decidim.plans"), new_plan_path, class: "button tiny button--simple" %>
+    <% end %>
+  </div>
+</div>

data/app/views/decidim/plans/admin/plans/_form.html.erb

@@ -0,0 +1,62 @@
+<%
+# Force the form to be multipart for the file uploads.
+# Calling Decidim form builder's own `upload` builder method should already do
+# this but it is not working in our case since we have multiple file fields.
+form.multipart = true
+%>
+
+<div class="card">
+  <div class="card-divider">
+    <h2 class="card-title"><%= title %></h2>
+  </div>
+
+  <div class="card-section">
+    <div class="row column">
+      <%= attached_proposals_picker_field form, :proposals %>
+    </div>
+
+    <%= javascript_include_tag "decidim/plans/proposal_picker" %>
+    <%= stylesheet_link_tag "decidim/plans/proposal_picker" %>
+
+    <div class="row column">
+      <%= remaining_characters("plans_title", component_settings.plan_title_length) do |opts| %>
+        <% if component_settings.multilingual_answers? %>
+          <%= form.translated :text_field, :title, opts.merge(tabs_id: "title-tabs") %>
+        <% else %>
+          <%= form.text_field(
+            "title_#{current_locale}".to_sym,
+            {
+              label: form.label_for(:title)
+            }.merge(opts)
+          ) %>
+        <% end %>
+      <% end %>
+    </div>
+
+    <% if @form.categories&.any? %>
+      <div class="row column">
+        <%= form.categories_select :category_id, @form.categories, prompt: t(".select_a_category") %>
+      </div>
+    <% end %>
+
+    <% if current_participatory_space.has_subscopes? %>
+      <div class="row column">
+        <%= scopes_picker_field form, :scope_id %>
+      </div>
+    <% end %>
+
+    <% @form.contents.each_with_index do |content, idx| %>
+      <%= fields_for "contents[]", content do |content_form| %>
+        <%= render "decidim/plans/shared/section_content_field", form: content_form, id: tabs_id_for_content(idx) %>
+      <% end %>
+    <% end %>
+
+    <% if component_settings.attachments_allowed? %>
+      <div class="row column">
+        <%= render partial: "decidim/plans/shared/attachments", object: form, locals: { form: form, blank_attachment: blank_attachment, component_settings: component_settings } %>
+      </div>
+    <% end %>
+  </div>
+</div>
+
+<%= javascript_include_tag "decidim/plans/plans_form" %>

data/app/views/decidim/plans/admin/plans/_js-callout.html.erb

@@ -0,0 +1,6 @@
+<div class="callout callout--full <%= css %>" data-closable>
+  <%= text %>
+  <button class="close-button" type="button" data-close="">
+    <span aria-hidden="true">×</span>
+  </button>
+</div>