decidim-plans 0.15.0

data/app/helpers/decidim/plans/traceability_helper.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A Helper to find and render the author of a version.
+    module TraceabilityHelper
+      include Decidim::TraceabilityHelper
+
+      # Caches a DiffRenderer instance for the `current_version`.
+      def item_diff_renderers
+        @item_diff_renderers ||= item_versions.map do |version|
+          renderer_for(version)
+        end.compact
+      end
+
+      def associated_diff_renderers
+        @associated_diff_renderers ||= associated_versions.map do |version|
+          renderer_for(version)
+        end.compact
+      end
+
+      def content_diff_renderers
+        @content_diff_renderers ||= content_versions.map do |version|
+          renderer_for(version)
+        end.compact
+      end
+
+      def diff_renderers
+        item_diff_renderers + associated_diff_renderers + content_diff_renderers
+      end
+
+      private
+
+      def renderer_for(version)
+        locale = current_locale unless component_settings.multilingual_answers?
+
+        renderer_klass =
+          case version.item.class.name
+          when "Decidim::Plans::Plan"
+            Decidim::Plans::DiffRenderer::Plan
+          when "Decidim::Plans::Content"
+            Decidim::Plans::DiffRenderer::Content
+          when "Decidim::Categorization"
+            Decidim::Plans::DiffRenderer::Categorization
+          end
+
+        renderer_klass.new(version, locale)
+      end
+
+      # Renders the given value in a user-friendly way based on the value class.
+      #
+      # value - an object to be rendered
+      #
+      # Returns an HTML-ready String.
+      def render_diff_value(value, type, action, options = {})
+        return "".html_safe if value.blank?
+
+        value_to_render = case type
+                          when :date
+                            l value, format: :long
+                          when :percentage
+                            number_to_percentage value, precision: 2
+                          when :translatable
+                            value.to_s
+                          else
+                            value
+                          end
+
+        content_tag(:div, class: "card--list__item #{action}") do
+          content_tag(:div, class: "card--list__text") do
+            content_tag(:div, { class: "diff__value" }.merge(options)) do
+              value_to_render
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/plans/user_group_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module UserGroupHelper
+      # Renders a user_group select field in a form.
+      # form - FormBuilder object
+      # name - attribute user_group_id
+      #
+      # Returns nothing.
+      def user_group_select_field(form, name)
+        selected = @form.user_group_id.presence
+        user_groups = Decidim::UserGroups::ManageableUserGroups.for(current_user).verified
+        form.select(
+          name,
+          user_groups.map { |g| [g.name, g.id] },
+          selected: selected,
+          include_blank: current_user.name
+        )
+      end
+    end
+  end
+end

data/app/models/concerns/decidim/plans/traceable.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+require_dependency "paper_trail/frameworks/active_record"
+
+module Decidim
+  module Plans
+    # A concern that adds traceabilty capability to the given model. Including
+    # this allows you the keep track of changes in the model attributes and
+    # changes authorship.
+    #
+    # Example:
+    #
+    #     class MyModel < ApplicationRecord
+    #       include Decidim::Plans::Traceable
+    #     end
+    module Traceable
+      extend ActiveSupport::Concern
+
+      included do
+        # This is customized with the `:ignore` option since we don't want to
+        # store another version when the item is published.
+        has_paper_trail ignore: [:published_at],
+                        class_name: "Decidim::Plans::PaperTrail::Version"
+
+        delegate :count, to: :versions, prefix: true
+
+        def last_whodunnit
+          versions.last.try(:whodunnit)
+        end
+
+        def last_editor
+          Decidim.traceability.version_editor(versions.last)
+        end
+      end
+
+      # This is needed for the action logs to work properly. They are only
+      # stored against models that implement Decidim::Traceable. However, we
+      # cannot directly include that module because we want to modify its
+      # functionality.
+      def is_a?(klass)
+        return true if klass == Decidim::Traceable
+        super
+      end
+    end
+  end
+end

data/app/models/decidim/plans/application_record.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # Abstract class from which all models in this engine inherit.
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/app/models/decidim/plans/attached_proposal.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # This class holds the association between a Plan and a
+    # Decidim::Proposals::Proposal.
+    class AttachedProposal < ApplicationRecord
+      belongs_to :plan, class_name: "Decidim::Plans::Plan", foreign_key: "decidim_plan_id"
+      belongs_to :proposal, class_name: "Decidim::Proposals::Proposal", foreign_key: "decidim_proposal_id"
+    end
+  end
+end

data/app/models/decidim/plans/content.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # The content record is the actual content for each plan section for a
+    # single plan.
+    class Content < Plans::ApplicationRecord
+      include Decidim::Plans::Traceable
+
+      self.table_name = "decidim_plans_plan_contents"
+
+      belongs_to :plan, class_name: "Decidim::Plans::Plan", foreign_key: "decidim_plan_id"
+      belongs_to :section, class_name: "Decidim::Plans::Section", foreign_key: "decidim_section_id"
+      belongs_to :user, class_name: "Decidim::User", foreign_key: "decidim_user_id"
+
+      def title
+        section.body
+      end
+    end
+  end
+end

data/app/models/decidim/plans/paper_trail/version.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module PaperTrail
+      class Version < ::PaperTrail::Version
+        self.table_name = "versions"
+
+        # Since the test suite has test coverage for this, we want to declare
+        # the association when the test suite is running. This makes it pass
+        # when DB is not initialized prior to test runs such as when we run on
+        # Travis CI Ex. (there won't be a db in `spec/dummy_app/db/`).
+        has_many :version_associations,
+                 class_name: "Decidim::Plans::PaperTrail::VersionAssociation",
+                 dependent: :destroy
+
+        scope(:within_transaction, ->(id) { where transaction_id: id })
+
+        # Track the associations on the plans object
+        def track_associations?
+          true
+        end
+      end
+    end
+  end
+end

data/app/models/decidim/plans/paper_trail/version_association.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module PaperTrail
+      class VersionAssociation < ::ActiveRecord::Base
+        self.table_name = "version_associations"
+
+        belongs_to :version,
+                   class_name: "Decidim::Plans::PaperTrail::Version"
+      end
+    end
+  end
+end

data/app/models/decidim/plans/plan.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A plan is similar to a proposal but allows the users to fill in multiple
+    # custom fields that the admin users define for each plans component. The
+    # fields are the plan sections and the contents are in plan contents.
+    class Plan < Plans::ApplicationRecord
+      include Decidim::Resourceable
+      include Decidim::Coauthorable
+      include Decidim::HasComponent
+      include Decidim::ScopableComponent
+      include Decidim::HasCategory
+      include Decidim::Reportable
+      include Decidim::HasAttachments
+      include Decidim::Followable
+      include Decidim::Comments::Commentable
+      include Decidim::Searchable
+      include Decidim::Plans::Traceable
+      include Decidim::Loggable
+
+      component_manifest_name "plans"
+
+      has_many :collaborator_requests,
+               class_name: "Decidim::Plans::PlanCollaboratorRequest",
+               foreign_key: :decidim_plan_id,
+               dependent: :destroy
+
+      has_many :requesters,
+               through: :collaborator_requests,
+               source: :user,
+               class_name: "Decidim::User",
+               foreign_key: :decidim_user_id
+
+      has_many :attached_proposals, foreign_key: :decidim_plan_id, dependent: :destroy
+      has_many :proposals, through: :attached_proposals
+
+      has_many :contents, foreign_key: :decidim_plan_id, dependent: :destroy
+
+      scope :open, -> { where(state: "open") }
+      scope :accepted, -> { where(state: "accepted") }
+      scope :rejected, -> { where(state: "rejected") }
+      scope :evaluating, -> { where(state: "evaluating") }
+      scope :withdrawn, -> { where(state: "withdrawn") }
+      scope :except_rejected, -> { where.not(state: "rejected").or(where(state: nil)) }
+      scope :except_withdrawn, -> { where.not(state: "withdrawn").or(where(state: nil)) }
+      scope :drafts, -> { where(published_at: nil) }
+      scope :published, -> { where.not(published_at: nil) }
+
+      acts_as_list scope: :decidim_component_id
+
+      searchable_fields(
+        {
+          scope_id: :decidim_scope_id,
+          participatory_space: { component: :participatory_space },
+          A: :search_title,
+          datetime: :published_at
+        },
+        index_on_create: ->(proposal) { proposal.visible? },
+        index_on_update: ->(proposal) { proposal.visible? }
+      )
+
+      def sections
+        Section.where(component: component).order(:position)
+      end
+
+      def self.order_randomly(seed)
+        transaction do
+          connection.execute("SELECT setseed(#{connection.quote(seed)})")
+          order(Arel.sql("RANDOM()")).load
+        end
+      end
+
+      def self.log_presenter_class_for(_log)
+        Decidim::Plans::AdminLog::PlanPresenter
+      end
+
+      # Returns a collection scoped by an author.
+      # Overrides this method in DataPortability to support Coauthorable.
+      def self.user_collection(author)
+        return unless author.is_a?(Decidim::User)
+
+        joins(:coauthorships)
+          .where("decidim_coauthorships.coauthorable_type = ?", name)
+          .where("decidim_coauthorships.decidim_author_id = ? AND decidim_coauthorships.decidim_author_type = ? ", author.id, author.class.base_class.name)
+      end
+
+      # Public: Checks if the plan is open for edits.
+      #
+      # Returns Boolean.
+      def open?
+        state == "open"
+      end
+
+      # Public: Checks if the plan has been published or not.
+      #
+      # Returns Boolean.
+      def published?
+        published_at.present?
+      end
+
+      # Public: Checks if the organization has given an answer for the plan.
+      #
+      # Returns Boolean.
+      def answered?
+        answered_at.present? && state.present?
+      end
+
+      # Public: Checks if the organization has accepted a plan.
+      #
+      # Returns Boolean.
+      def accepted?
+        answered? && state == "accepted"
+      end
+
+      # Public: Checks if the organization has rejected a plan.
+      #
+      # Returns Boolean.
+      def rejected?
+        answered? && state == "rejected"
+      end
+
+      # Public: Checks if the organization has marked the plan as evaluating it.
+      #
+      # Returns Boolean.
+      def evaluating?
+        answered? && state == "evaluating"
+      end
+
+      # Public: Checks if the author has withdrawn the plan.
+      #
+      # Returns Boolean.
+      def withdrawn?
+        state == "withdrawn"
+      end
+
+      # Public: Overrides the `reported_content_url` Reportable concern method.
+      def reported_content_url
+        ResourceLocatorPresenter.new(self).url
+      end
+
+      # Checks whether the user can edit the given plan.
+      #
+      # user - the user to check for authorship
+      def editable_by?(user)
+        !answered? && !copied_from_other_component? && authored_by?(user)
+      end
+
+      # Checks whether the user can withdraw the given plan.
+      #
+      # user - the user to check for withdrawability.
+      def withdrawable_by?(user)
+        user && !withdrawn? && creator_author == user && !copied_from_other_component?
+      end
+
+      # Public: Whether the plan is a draft or not.
+      def draft?
+        published_at.nil?
+      end
+
+      def commentable?
+        component.settings.comments_enabled?
+      end
+
+      def accepts_new_comments?
+        commentable? && !component.current_settings.comments_blocked
+      end
+
+      def comments_have_alignment?
+        true
+      end
+
+      def comments_have_votes?
+        true
+      end
+
+      def users_to_notify_on_comment_created
+        followers
+      end
+
+      # method for sort_link by number of comments
+      ransacker :commentable_comments_count do
+        query = <<-SQL
+        (SELECT COUNT(decidim_comments_comments.id)
+         FROM decidim_comments_comments
+         WHERE decidim_comments_comments.decidim_commentable_id = decidim_plans_plans.id
+         AND decidim_comments_comments.decidim_commentable_type = 'Decidim::Plans::Plan'
+         GROUP BY decidim_comments_comments.decidim_commentable_id
+         )
+        SQL
+        Arel.sql(query)
+      end
+
+      # Checks whether the plan is inside the time window to be editable or not once published.
+      def within_edit_time_limit?
+        true
+      end
+
+      private
+
+      def copied_from_other_component?
+        linked_resources(:plans, "copied_from_component").any?
+      end
+    end
+  end
+end

data/app/models/decidim/plans/plan_collaborator_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A plan can accept requests to coauthor and contribute
+    class PlanCollaboratorRequest < Plans::ApplicationRecord
+      validates :plan, :user, presence: true
+
+      belongs_to :plan, class_name: "Decidim::Plans::Plan", foreign_key: :decidim_plan_id
+      belongs_to :user, class_name: "Decidim::User", foreign_key: :decidim_user_id
+    end
+  end
+end

data/app/models/decidim/plans/section.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    # A plan section is a record that stores the question data and order of
+    # items that the users need to fill for each plan. The actual contents of
+    # the plans are stored in the Decidim::Plans::Content records.
+    class Section < Plans::ApplicationRecord
+      include Decidim::HasComponent
+
+      TYPES = %w(field_text_multiline field_text).freeze
+
+      validates :section_type, inclusion: { in: TYPES }
+    end
+  end
+end

data/app/permissions/decidim/plans/admin/permissions.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module Admin
+      class Permissions < Decidim::DefaultPermissions
+        def permissions
+          return permission_action unless user
+
+          return permission_action if permission_action.scope != :admin
+
+          toggle_allow(admin_plan_answering_is_enabled?) if
+            permission_action.action == :create &&
+            permission_action.subject == :plan_answer
+
+          return permission_action if permission_action.subject != :plan &&
+                                      permission_action.subject != :plans &&
+                                      permission_action.subject != :section &&
+                                      permission_action.subject != :sections
+
+          case permission_action.action
+          when :create
+            permission_action.allow!
+          when :edit, :update, :destroy
+            permission_action.allow! if plan.present? || section.present?
+          end
+
+          permission_action
+        end
+
+        private
+
+        def plan
+          @plan ||= context.fetch(:plan, nil)
+        end
+
+        def admin_plan_answering_is_enabled?
+          current_settings.try(:plan_answering_enabled) &&
+            component_settings.try(:plan_answering_enabled)
+        end
+      end
+    end
+  end
+end

data/app/permissions/decidim/plans/permissions.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    class Permissions < Decidim::DefaultPermissions
+      def permissions
+        return permission_action unless user
+
+        # Delegate the admin permission checks to the admin permissions class
+        return Decidim::Plans::Admin::Permissions.new(user, permission_action, context).permissions if permission_action.scope == :admin
+        return permission_action if permission_action.scope != :public
+
+        if permission_action.subject == :plan
+          apply_plan_permissions(permission_action)
+        else
+          permission_action
+        end
+
+        permission_action
+      end
+
+      private
+
+      def plan
+        @plan ||= context.fetch(:plan, nil)
+      end
+
+      def apply_plan_permissions(permission_action)
+        case permission_action.action
+        when :create
+          can_create_plan?
+        when :edit
+          can_edit_plan?
+        when :withdraw
+          can_withdraw_plan?
+        when :publish
+          can_publish_plan?
+        when :request_access
+          can_request_access_plan?
+        end
+      end
+
+      def can_create_plan?
+        toggle_allow(authorized?(:create) && current_settings&.creation_enabled?)
+      end
+
+      def can_edit_plan?
+        toggle_allow(plan.open? && plan.editable_by?(user))
+      end
+
+      def can_withdraw_plan?
+        toggle_allow(plan && plan.withdrawable_by?(user))
+      end
+
+      def can_publish_plan?
+        toggle_allow(plan.open? && plan.editable_by?(user))
+      end
+
+      def can_request_access_plan?
+        return toggle_allow(false) unless plan.open?
+        return toggle_allow(false) if plan.editable_by?(user)
+        return toggle_allow(false) if plan.requesters.include? user
+        toggle_allow(plan && !plan.editable_by?(user))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module AdminLog
+      # This class holds the logic to present a `Decidim::Plans::Plan`
+      # for the `AdminLog` log.
+      #
+      # Usage should be automatic and you shouldn't need to call this class
+      # directly, but here's an example:
+      #
+      #    action_log = Decidim::ActionLog.last
+      #    view_helpers # => this comes from the views
+      #    PlanPresenter.new(action_log, view_helpers).present
+      class PlanPresenter < Decidim::Log::BasePresenter
+        private
+
+        def resource_presenter
+          @resource_presenter ||= Decidim::Plans::Log::ResourcePresenter.new(action_log.resource, h, action_log.extra["resource"])
+        end
+
+        def diff_fields_mapping
+          {
+            state: "Decidim::Plans::AdminLog::ValueTypes::PlanStatePresenter",
+            answered_at: :date,
+            answer: :i18n
+          }
+        end
+
+        def action_string
+          case action
+          when "answer", "create", "update"
+            "decidim.plans.admin_log.plan.#{action}"
+          else
+            super
+          end
+        end
+
+        def i18n_labels_scope
+          "activemodel.attributes.plan"
+        end
+
+        def has_diff?
+          action == "answer" || super
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/plans/admin_log/value_types/plan_state_presenter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module AdminLog
+      module ValueTypes
+        class PlanStatePresenter < Decidim::Log::ValueTypes::DefaultPresenter
+          def present
+            return unless value
+            h.t(value, scope: "decidim.plans.admin.plan_answers.edit", default: value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    #
+    # Decorator for contents
+    #
+    class ContentPresenter < SimpleDelegator
+      include Rails.application.routes.mounted_helpers
+      include TranslatableAttributes
+
+      def content
+        __getobj__
+      end
+
+      def title
+        translated_attribute(content.title).html_safe
+      end
+
+      def body
+        translated_attribute(content.body).html_safe
+      end
+    end
+  end
+end