decidim-comments 0.23.3 → 0.24.1

data/app/cells/decidim/comments/comment_thread/title.erb

@@ -0,0 +1,3 @@
+<h6 class="comment-thread__title">
+  <%= t("decidim.components.comment_thread.title", authorName: author_name) %>
+</h6>

data/app/cells/decidim/comments/comment_thread_cell.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Comments
+    # A cell to display a comment thread.
+    class CommentThreadCell < Decidim::ViewModel
+      def title
+        return unless has_threads?
+
+        render :title
+      end
+
+      private
+
+      def has_threads?
+        model.comment_threads.any?
+      end
+
+      def author_name
+        return t("decidim.components.comment.deleted_user") if model.author.deleted?
+
+        model.author.name
+      end
+
+      def order
+        options[:order] || "older"
+      end
+    end
+  end
+end

data/app/cells/decidim/comments/comments/add_comment.erb

@@ -0,0 +1,30 @@
+<div class="add-comment">
+  <h4 class="section-heading"><%= t("decidim.components.add_comment_form.title") %></h4>
+
+  <% if user_signed_in? %>
+    <% if alignment_enabled? %>
+      <div class="opinion-toggle button-group">
+        <button class="button tiny button--muted opinion-toggle--ok">
+          <%= icon "thumb-up", role: "none presentation" %>
+        </button>
+        <button class="button tiny button--muted opinion-toggle--meh is-active">
+          <%= t("decidim.components.add_comment_form.opinion.neutral") %>
+        </button>
+        <button class="button tiny button--muted opinion-toggle--ko">
+          <%= icon "thumb-down", role: "none presentation" %>
+        </button>
+      </div>
+    <% end %>
+    <%== cell("decidim/comments/comment_form", model, root_depth: root_depth) %>
+  <% else %>
+    <p>
+      <span>
+        <%== t(
+          "decidim.components.add_comment_form.account_message",
+          sign_in_url: decidim.new_user_session_path,
+          sign_up_url: decidim.new_user_registration_path
+        ) %>
+      </span>
+    </p>
+  <% end %>
+</div>

data/app/cells/decidim/comments/comments/blocked_comments_warning.erb

@@ -0,0 +1,3 @@
+<div class="callout warning">
+  <p><%= t("decidim.components.comments.blocked_comments_warning") %></p>
+</div>

data/app/cells/decidim/comments/comments/order_control.erb

@@ -0,0 +1,37 @@
+<div class="order-by__dropdown order-by__dropdown--right">
+  <span class="order-by__text"><%= t("decidim.components.comment_order_selector.title") %></span>
+  <ul class="dropdown menu"
+    data-dropdown-menu="data-dropdown-menu"
+    data-autoclose="false"
+    data-disable-hover="true"
+    data-click-open="true"
+    data-close-on-click="true"
+    tabindex="-1"
+    role="menubar">
+    <li class="is-dropdown-submenu-parent opens-right" tabindex="-1" role="none">
+      <a href="#" id="comments-order-menu-control"
+        aria-label="<%= t("decidim.components.comment_order_selector.title") %>"
+        aria-controls="comments-order-menu"
+        aria-haspopup="true"
+        role="menuitem"><%= t("decidim.components.comment_order_selector.order.#{order}") %></a>
+      <ul class="menu is-dropdown-submenu submenu first-sub vertical"
+        id="comments-order-chooser-menu"
+        role="menu"
+        aria-labelledby="comments-order-menu-control"
+        tabindex="-1"
+        data-submenu="">
+        <% available_orders.each do |order_value| %>
+          <li role="none" class="is-submenu-item is-dropdown-submenu-item">
+            <%= link_to(
+              t("decidim.components.comment_order_selector.order.#{order_value}"),
+              decidim_comments.comments_path(commentable_gid: model.to_signed_global_id.to_s, order: order_value, reload: 1),
+              tabindex: -1,
+              role: "menuitem",
+              remote: true
+            ) %>
+          </li>
+        <% end %>
+      </ul>
+    </li>
+  </ul>
+</div>

data/app/cells/decidim/comments/comments/show.erb

@@ -0,0 +1,32 @@
+<%= content_tag :div, id: node_id, data: { decidim_comments: comments_data } do %>
+  <div class="columns large-9 comments-container" id="comments">
+    <div class="comments">
+      <div class="row collapse order-by">
+        <h2 class="order-by__text section-heading">
+          <% if single_comment? %>
+            <%= t("decidim.components.comments.comment_details_title") %>
+          <% else %>
+            <span class="comments-count">
+              <%= t("decidim.components.comments.title", count: comments_count) %>
+            </span>
+          <% end %>
+        </h2>
+        <%= render :order_control %>
+      </div>
+      <%= single_comment_warning %>
+      <%= blocked_comments_warning %>
+      <div class="comment-threads">
+        <% comments.each do |comment| %>
+          <%= cell("decidim/comments/comment_thread", comment, order: order) %>
+        <% end %>
+      </div>
+      <%= add_comment %>
+      <%= user_comments_blocked_warning %>
+    </div>
+    <div class="callout primary loading-comments hide">
+      <p><%= t("decidim.components.comments.loading") %></p>
+    </div>
+  </div>
+<% end %>
+
+<%= javascript_include_tag("decidim/comments/comments") %>

data/app/cells/decidim/comments/comments/single_comment_warning.erb

@@ -0,0 +1,9 @@
+<div class="callout secondary">
+  <h5><%= t("decidim.components.comments.single_comment_warning_title") %></h5>
+  <p>
+    <%== t(
+    "decidim.components.comments.single_comment_warning",
+    url: "#{commentable_path}##{node_id}"
+    ) %>
+  </p>
+</div>

data/app/cells/decidim/comments/comments/user_comments_blocked_warning.erb

@@ -0,0 +1,3 @@
+<div class="callout warning">
+  <p><%= t("decidim.components.comments.blocked_comments_for_user_warning") %></p>
+</div>

data/app/cells/decidim/comments/comments_cell.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Comments
+    # A cell to display a comments section for a commentable object.
+    class CommentsCell < Decidim::ViewModel
+      include Decidim::IconHelper
+
+      delegate :user_signed_in?, to: :controller
+
+      def add_comment
+        return if single_comment?
+        return if comments_blocked?
+        return if user_comments_blocked?
+
+        render :add_comment
+      end
+
+      def single_comment_warning
+        return unless single_comment?
+
+        render :single_comment_warning
+      end
+
+      def blocked_comments_warning
+        return unless comments_blocked?
+        return unless user_comments_blocked?
+
+        render :blocked_comments_warning
+      end
+
+      def user_comments_blocked_warning
+        return if comments_blocked? # Shows already the general warning
+        return unless user_comments_blocked?
+
+        render :user_comments_blocked_warning
+      end
+
+      private
+
+      def decidim_comments
+        Decidim::Comments::Engine.routes.url_helpers
+      end
+
+      def comments
+        if single_comment?
+          [single_comment]
+        else
+          SortedComments.for(model, order_by: order)
+        end
+      end
+
+      def comments_count
+        model.comments.count
+      end
+
+      def root_depth
+        return 0 unless single_comment?
+
+        single_comment.depth
+      end
+
+      def commentable_path(params = {})
+        resource_locator(model).path(params)
+      end
+
+      def alignment_enabled?
+        model.comments_have_alignment?
+      end
+
+      def available_orders
+        %w(best_rated recent older most_discussed)
+      end
+
+      def order
+        options[:order] || "older"
+      end
+
+      def decidim
+        Decidim::Core::Engine.routes.url_helpers
+      end
+
+      def node_id
+        "comments-for-#{commentable_type.demodulize}-#{model.id}"
+      end
+
+      def commentable_type
+        model.commentable_type
+      end
+
+      def comments_data
+        {
+          singleComment: single_comment?,
+          toggleTranslations: machine_translations_toggled?,
+          commentableGid: model.to_signed_global_id.to_s,
+          commentsUrl: decidim_comments.comments_path,
+          rootDepth: root_depth,
+          lastCommentId: last_comment_id,
+          order: order
+        }
+      end
+
+      def last_comment_id
+        Decidim::Comments::Comment.where(
+          root_commentable: model
+        ).order(:id).pluck(:id).last
+      end
+
+      def single_comment?
+        single_comment.present?
+      end
+
+      def single_comment
+        return if options[:single_comment].blank?
+
+        @single_comment ||= model.comments.find_by(id: options[:single_comment])
+      end
+
+      def machine_translations_toggled?
+        options[:machine_translations] == true
+      end
+
+      def comments_blocked?
+        !model.accepts_new_comments?
+      end
+
+      def user_comments_blocked?
+        return false unless user_signed_in?
+
+        !model.user_allowed_to_comment?(current_user)
+      end
+    end
+  end
+end

data/app/commands/decidim/comments/vote_comment.rb

@@ -23,27 +23,51 @@ module Decidim
       #
       # Returns nothing.
       def call
-        if @weight == 1
-          vote = @comment.up_votes.find_by(author: @author)
-          if vote
-            vote.destroy!
+        case @weight
+        when 1
+          previous_vote = @comment.up_votes.find_by(author: @author)
+          if previous_vote
+            previous_vote.destroy!
           else
-            @comment.up_votes.create!(author: @author)
+            @vote = @comment.up_votes.create!(author: @author)
           end
-        elsif @weight == -1
-          vote = @comment.down_votes.find_by(author: @author)
-          if vote
-            vote.destroy!
+        when -1
+          previous_vote = @comment.down_votes.find_by(author: @author)
+          if previous_vote
+            previous_vote.destroy!
           else
-            @comment.down_votes.create!(author: @author)
+            @vote = @comment.down_votes.create!(author: @author)
           end
         else
           return broadcast(:invalid)
         end
+
+        notify_comment_author if @vote
         broadcast(:ok, @comment)
       rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
         broadcast(:invalid)
       end
+
+      def notify_comment_author
+        Decidim::EventsManager.publish(
+          event: "decidim.events.comments.comment_#{upvote? ? "upvoted" : "downvoted"}",
+          event_class: upvote? ? Decidim::Comments::CommentUpvotedEvent : Decidim::Comments::CommentDownvotedEvent,
+          resource: @comment.commentable,
+          affected_users: [@comment.author],
+          extra: {
+            comment_id: @comment.id,
+            weight: @weight,
+            downvotes: @comment.down_votes.count,
+            upvotes: @comment.up_votes.count
+          }
+        )
+      end
+
+      private
+
+      def upvote?
+        @weight.positive?
+      end
     end
   end
 end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Comments
+    # This controller is the abstract class from which all other controllers of
+    # this engine inherit.
+    class ApplicationController < Decidim::ApplicationController
+      def permission_class_chain
+        [
+          ::Decidim::Comments::Permissions,
+          ::Decidim::Permissions
+        ]
+      end
+    end
+  end
+end

data/app/controllers/decidim/comments/comments_controller.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Comments
+    # Controller that manages the comments for a commentable object.
+    #
+    class CommentsController < Decidim::Comments::ApplicationController
+      include Decidim::ResourceHelper
+
+      before_action :authenticate_user!, only: [:create]
+      before_action :set_commentable
+      before_action :ensure_commentable!
+
+      helper_method :root_depth, :commentable, :order, :reply?, :reload?
+
+      def index
+        enforce_permission_to :read, :comment, commentable: commentable
+
+        @comments = SortedComments.for(
+          commentable,
+          order_by: order,
+          after: params.fetch(:after, 0).to_i
+        )
+        @comments_count = commentable.comments.count
+
+        respond_to do |format|
+          format.js do
+            if reload?
+              render :reload
+            else
+              render :index
+            end
+          end
+
+          # This makes sure bots are not causing unnecessary log entries.
+          format.html { redirect_to commentable_path }
+        end
+      end
+
+      def create
+        enforce_permission_to :create, :comment, commentable: commentable
+
+        form = Decidim::Comments::CommentForm.from_params(
+          params.merge(commentable: commentable)
+        ).with_context(
+          current_organization: current_organization,
+          current_component: commentable.component
+        )
+        Decidim::Comments::CreateComment.call(form, current_user) do
+          on(:ok) do |comment|
+            handle_success(comment)
+            respond_to do |format|
+              format.js { render :create }
+            end
+          end
+
+          on(:invalid) do
+            @error = t("create.error", scope: "decidim.comments.comments")
+            respond_to do |format|
+              format.js { render :error }
+            end
+          end
+        end
+      end
+
+      private
+
+      attr_reader :commentable, :comment
+
+      def set_commentable
+        @commentable = GlobalID::Locator.locate_signed(commentable_gid)
+      end
+
+      def ensure_commentable!
+        raise ActionController::RoutingError, "Not Found" unless commentable
+      end
+
+      def handle_success(comment)
+        @comment = comment
+        @comments_count = begin
+          case commentable
+          when Decidim::Comments::Comment
+            commentable.root_commentable.comments.count
+          else
+            commentable.comments.count
+          end
+        end
+      end
+
+      def commentable_gid
+        case action_name
+        when "create"
+          params.require(:comment).fetch(:commentable_gid)
+        else
+          params.fetch(:commentable_gid, nil)
+        end
+      end
+
+      def reply?(comment)
+        comment.root_commentable != comment.commentable
+      end
+
+      def order
+        params.fetch(:order, "older")
+      end
+
+      def reload?
+        params.fetch(:reload, 0).to_i == 1
+      end
+
+      def root_depth
+        params.fetch(:root_depth, 0).to_i
+      end
+
+      def commentable_path
+        return commentable.polymorphic_resource_path({}) if commentable&.respond_to?(:polymorphic_resource_path)
+
+        resource_locator(commentable).path
+      end
+    end
+  end
+end