decidim-debates 0.22.0 → 0.23.0

data/app/controllers/decidim/debates/orderable.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module Debates
+    # Common logic to sorting resources
+    module Orderable
+      extend ActiveSupport::Concern
+
+      included do
+        include Decidim::Orderable
+
+        private
+
+        def available_orders
+          @available_orders ||= %w(random recent commented updated)
+        end
+
+        def default_order
+          "updated"
+        end
+
+        def reorder(debates)
+          case order
+          when "recent"
+            debates.order("created_at DESC")
+          when "commented"
+            debates.order("comments_count DESC")
+          when "updated"
+            debates.order("updated_at DESC")
+          when "random"
+            debates.order_randomly(random_seed)
+          else
+            debates
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Debates
+    # Exposes Debates versions so users can see how a Debate has been updated
+    # through time.
+    class VersionsController < Decidim::Proposals::ApplicationController
+      include Decidim::ApplicationHelper
+      include Decidim::ResourceVersionsConcern
+
+      def versioned_resource
+        @versioned_resource ||= present(Debate.where(component: current_component).find(params[:debate_id]))
+      end
+    end
+  end
+end

data/app/controllers/decidim/debates/widgets_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Debates
+    class WidgetsController < Decidim::WidgetsController
+      helper Debates::ApplicationHelper
+
+      private
+
+      def model
+        @model ||= Debate.where(component: params[:component_id]).find(params[:debate_id])
+      end
+
+      def iframe_url
+        @iframe_url ||= debate_widget_url(model)
+      end
+    end
+  end
+end

data/app/events/decidim/debates/close_debate_event.rb

@@ -0,0 +1,15 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Debates
+    class CloseDebateEvent < Decidim::Events::SimpleEvent
+      def resource_text
+        translated_attribute(resource.conclusions)
+      end
+
+      def event_has_roles?
+        true
+      end
+    end
+  end
+end

data/app/forms/decidim/debates/admin/close_debate_form.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Debates
+    module Admin
+      # This class holds a Form to close debates from Decidim's admin views.
+      class CloseDebateForm < Decidim::Form
+        include TranslatableAttributes
+
+        mimic :debate
+
+        translatable_attribute :conclusions, String do |translated_attribute, locale|
+          validates translated_attribute, presence: true, if: ->(record) { record.default_locale?(locale) }
+          validates translated_attribute, length: { minimum: 10, maximum: 10_000 }, if: ->(record) { record.default_locale?(locale) }
+        end
+
+        attribute :debate, Debate
+
+        validates :debate, presence: true
+        validate :user_can_close_debate
+
+        def closed_at
+          debate&.closed_at || Time.current
+        end
+
+        private
+
+        def user_can_close_debate
+          errors.add(:debate, :invalid) unless debate.official?
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/debates/admin/debate_form.rb

@@ -24,7 +24,11 @@ module Decidim
         validates :category, presence: true, if: ->(form) { form.decidim_category_id.present? }
 
         def map_model(model)
-          self.decidim_category_id = model.category.try(:id)
+          self.decidim_category_id = model.categorization.decidim_category_id if model.categorization
+          presenter = DebatePresenter.new(model)
+
+          self.title = presenter.title(all_locales: title.is_a?(Hash))
+          self.description = presenter.description(all_locales: description.is_a?(Hash))
         end
 
         def category

data/app/forms/decidim/debates/close_debate_form.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Debates
+    # This class holds a Form to close debates from Decidim's public views.
+    class CloseDebateForm < Decidim::Form
+      mimic :debate
+
+      attribute :conclusions, String
+      attribute :debate, Debate
+
+      validates :debate, presence: true
+      validates :conclusions, presence: true, length: { minimum: 10, maximum: 10_000 }
+      validate :user_can_close_debate
+
+      def closed_at
+        debate&.closed_at || Time.current
+      end
+
+      def map_model(debate)
+        super
+        self.debate = debate
+
+        # Debates can be translated in different languages from the admin but
+        # the public form doesn't allow it. When a user closes a debate the
+        # user locale is taken as the text locale.
+        self.conclusions = debate.conclusions&.values&.first
+      end
+
+      private
+
+      def user_can_close_debate
+        return if !debate || !debate.respond_to?(:closeable_by?)
+
+        errors.add(:debate, :invalid) unless debate.closeable_by?(current_user)
+      end
+    end
+  end
+end

data/app/forms/decidim/debates/debate_form.rb

@@ -10,15 +10,41 @@ module Decidim
       attribute :description, String
       attribute :category_id, Integer
       attribute :user_group_id, Integer
+      attribute :debate, Debate
 
       validates :title, presence: true
       validates :description, presence: true
-
       validates :category, presence: true, if: ->(form) { form.category_id.present? }
+      validate :editable_by_user
+
+      def map_model(debate)
+        super
+        self.debate = debate
+
+        # Debates can be translated in different languages from the admin but
+        # the public form doesn't allow it. When a user creates a debate the
+        # user locale is taken as the text locale.
+        self.title = debate.title.values.first
+        self.description = debate.description.values.first
+        self.user_group_id = debate.decidim_user_group_id
+
+        if debate.category.present?
+          self.category_id = debate.category.id
+          @category = debate.category
+        end
+      end
 
       def category
         @category ||= current_component.categories.find_by(id: category_id)
       end
+
+      private
+
+      def editable_by_user
+        return unless debate.respond_to?(:editable_by?)
+
+        errors.add(:debate, :invalid) unless debate.editable_by?(current_user)
+      end
     end
   end
 end

data/app/helpers/decidim/debates/admin/application_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Debates
+    module Admin
+      # Custom helpers, scoped to the debates admin engine.
+      #
+      module ApplicationHelper
+        include Decidim::Admin::ResourceScopeHelper
+      end
+    end
+  end
+end

data/app/helpers/decidim/debates/application_helper.rb

@@ -8,6 +8,9 @@ module Decidim
       include PaginateHelper
       include Decidim::Comments::CommentsHelper
       include Decidim::RichTextEditorHelper
+      include Decidim::EndorsableHelper
+      include Decidim::FollowableHelper
+      include Decidim::CheckBoxesTreeHelper
 
       # If the debate is official or the rich text editor is enabled on the
       # frontend, the debate description is considered as safe content.
@@ -17,7 +20,7 @@ module Decidim
 
       # If the content is safe, HTML tags are sanitized, otherwise, they are stripped.
       def render_debate_description(debate)
-        description = present(debate).description(strip_tags: !safe_content?)
+        description = present(debate).description(strip_tags: !safe_content?, links: true)
 
         safe_content? ? decidim_sanitize(description) : simple_format(description)
       end
@@ -26,6 +29,39 @@ module Decidim
       def text_editor_for_debate_description(form)
         text_editor_for(form, :description)
       end
+
+      # Returns a TreeNode to be used in the list filters to filter debates by
+      # its origin.
+      def filter_origin_values
+        origin_values = []
+        origin_values << TreePoint.new("official", t("decidim.debates.debates.filters.official"))
+        origin_values << TreePoint.new("citizens", t("decidim.debates.debates.filters.citizens"))
+        origin_values << TreePoint.new("user_group", t("decidim.debates.debates.filters.user_groups")) if current_organization.user_groups_enabled?
+
+        TreeNode.new(TreePoint.new("", t("decidim.debates.debates.filters.all")), origin_values)
+      end
+
+      # Options to filter Debates by activity.
+      def activity_filter_values
+        base = [
+          ["all", t("decidim.debates.debates.filters.all")],
+          ["my_debates", t("decidim.debates.debates.filters.my_debates")]
+        ]
+        base += [["commented", t("decidim.debates.debates.filters.commented")]]
+        base
+      end
+
+      # Returns a TreeNode to be used in the list filters to filter debates by
+      # its state.
+      def filter_debates_state_values
+        Decidim::CheckBoxesTreeHelper::TreeNode.new(
+          Decidim::CheckBoxesTreeHelper::TreePoint.new("", t("decidim.debates.debates.filters.all")),
+          [
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("open", t("decidim.debates.debates.filters.state_values.open")),
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("closed", t("decidim.debates.debates.filters.state_values.closed"))
+          ]
+        )
+      end
     end
   end
 end

data/app/models/decidim/debates/debate.rb

@@ -11,7 +11,7 @@ module Decidim
       include Decidim::Resourceable
       include Decidim::Followable
       include Decidim::Comments::Commentable
-      include Decidim::ScopableComponent
+      include Decidim::ScopableResource
       include Decidim::Authorable
       include Decidim::Reportable
       include Decidim::HasReference
@@ -20,11 +20,17 @@ module Decidim
       include Decidim::DataPortability
       include Decidim::NewsletterParticipant
       include Decidim::Searchable
+      include Decidim::TranslatableResource
+      include Decidim::TranslatableAttributes
+      include Decidim::Endorsable
+      include Decidim::Randomable
 
+      belongs_to :last_comment_by, polymorphic: true, foreign_key: "last_comment_by_id", foreign_type: "last_comment_by_type", optional: true
       component_manifest_name "debates"
 
       validates :title, presence: true
 
+      translatable_fields :title, :description, :instructions, :information_updates
       searchable_fields({
                           participatory_space: { component: :participatory_space },
                           A: :title,
@@ -34,17 +40,23 @@ module Decidim
                         index_on_create: ->(debate) { debate.visible? },
                         index_on_update: ->(debate) { debate.visible? })
 
+      scope :open, -> { where(closed_at: nil) }
+      scope :closed, -> { where.not(closed_at: nil) }
+      scope :authored_by, ->(author) { where(author: author) }
+      scope :commented_by, lambda { |author|
+        joins(:comments).where(
+          decidim_comments_comments:
+          {
+            decidim_author_id: author.id,
+            decidim_author_type: author.class.base_class.name
+          }
+        )
+      }
+
       def self.log_presenter_class_for(_log)
         Decidim::Debates::AdminLog::DebatePresenter
       end
 
-      # Public: Checks whether the debate is official or not.
-      #
-      # Returns a boolean.
-      def official?
-        author.is_a?(Decidim::Organization)
-      end
-
       # Public: Overrides the `reported_content_url` Reportable concern method.
       def reported_content_url
         ResourceLocatorPresenter.new(self).url
@@ -82,6 +94,7 @@ module Decidim
       # Public: Overrides the `accepts_new_comments?` Commentable concern method.
       def accepts_new_comments?
         return false unless open?
+        return false if closed?
 
         commentable? && !comments_blocked?
       end
@@ -124,6 +137,45 @@ module Decidim
                                 .pluck(:decidim_author_id).flatten.compact.uniq
       end
 
+      # Checks whether the user can edit the debate.
+      #
+      # user - the user to check for authorship
+      def editable_by?(user)
+        !closed? && authored_by?(user)
+      end
+
+      # Checks whether the debate is closed or not.
+      #
+      def closed?
+        closed_at.present? && conclusions.present?
+      end
+
+      # Checks whether the user can edit the debate.
+      #
+      # user - the user to check for authorship
+      def closeable_by?(user)
+        authored_by?(user)
+      end
+
+      # Public: Updates the comments counter cache. We have to do it these
+      # way in order to properly calculate the counter with hidden
+      # comments.
+      #
+      # rubocop:disable Rails/SkipsModelValidations
+      def update_comments_count
+        comments_count = comments.not_hidden.count
+        last_comment = comments.not_hidden.order("created_at DESC").first
+
+        update_columns(
+          last_comment_at: last_comment&.created_at,
+          last_comment_by_id: last_comment&.decidim_author_id,
+          last_comment_by_type: last_comment&.decidim_author_type,
+          comments_count: comments_count,
+          updated_at: Time.current
+        )
+      end
+      # rubocop:enable Rails/SkipsModelValidations
+
       private
 
       def comments_blocked?

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

@@ -12,7 +12,9 @@ module Decidim
           case permission_action.action
           when :create, :read
             allow!
-          when :update, :delete
+          when :update
+            toggle_allow(debate && !debate.closed? && debate.official?)
+          when :delete, :close
             toggle_allow(debate && debate.official?)
           end
 

data/app/permissions/decidim/debates/permissions.rb

@@ -15,6 +15,12 @@ module Decidim
           toggle_allow(can_create_debate?)
         when :report
           allow!
+        when :edit
+          can_edit_debate?
+        when :endorse
+          can_endorse_debate?
+        when :close
+          can_close_debate?
         end
 
         permission_action
@@ -26,6 +32,28 @@ module Decidim
         authorized?(:create) &&
           current_settings&.creation_enabled? && component.participatory_space.can_participate?(user)
       end
+
+      def can_edit_debate?
+        return allow! if debate&.editable_by?(user)
+
+        disallow!
+      end
+
+      def can_close_debate?
+        return allow! if debate&.closeable_by?(user)
+
+        disallow!
+      end
+
+      def can_endorse_debate?
+        return disallow! if debate.closed?
+
+        allow!
+      end
+
+      def debate
+        @debate ||= context.fetch(:debate, nil) || context.fetch(:resource, nil)
+      end
     end
   end
 end