biovision-comment 0.1.170914 → 0.7.190905.0

data/app/controllers/comments_controller.rb

@@ -1,25 +1,29 @@
+# frozen_string_literal: true
+
+# Comments
 class CommentsController < ApplicationController
-  before_action :restrict_anonymous_access
-  before_action :restrict_access, except: [:create]
-  before_action :set_entity, only: [:show, :edit, :update, :destroy]
+  before_action :set_handler
+  before_action :restrict_access, except: %i[check create]
+  before_action :set_entity, only: %i[edit update destroy]
+
+  layout 'admin', except: :create
 
-  layout 'admin'
+  # post /comments/check
+  def check
+    @entity = Comment.instance_for_check(params[:entity_id], entity_parameters)
+
+    render 'shared/forms/check'
+  end
 
   # post /comments
   def create
-    @entity = Comment.new creation_parameters
-    if @entity.save
-      notify_participants
-      redirect_to(@entity.commentable || admin_comment_path(@entity.id), notice: t('comments.create.success'))
+    if params.key?(:agree)
+      emulate_creation
     else
-      render :new, layout: 'application', status: :bad_request
+      create_comment
     end
   end
 
-  # get /comments/:id
-  def show
-  end
-
   # get /comments/:id/edit
   def edit
   end
@@ -27,9 +31,9 @@ class CommentsController < ApplicationController
   # patch /comments/:id
   def update
     if @entity.update entity_parameters
-      redirect_to admin_comment_path(@entity.id), notice: t('comments.update.success')
+      form_processed_ok(admin_comment_path(id: @entity.id))
     else
-      render :edit, status: :bad_request
+      form_processed_with_error(:edit)
     end
   end
 
@@ -43,36 +47,45 @@ class CommentsController < ApplicationController
 
   private
 
+  def component_slug
+    Biovision::Components::CommentsComponent::SLUG
+  end
+
   def restrict_access
-    require_privilege :moderator
+    error = 'Managing comments is not allowed'
+    handle_http_401(error) unless component_handler.allow?('moderator')
+  end
+
+  def emulate_creation
+    form_processed_ok(root_path)
+  end
+
+  def create_comment
+    @entity = component_handler.create_comment(creation_parameters)
+    if @entity.valid?
+      notify_participants
+      next_page = param_from_request(:return_url)
+      form_processed_ok(next_page.match?(%r{\A/[^/]}) ? next_page : root_path)
+    else
+      form_processed_with_error(:new)
+    end
   end
 
   def set_entity
     @entity = Comment.find_by(id: params[:id])
-    if @entity.nil?
-      handle_http_404('Cannot find comment')
-    end
+    handle_http_404('Cannot find comment') if @entity.nil?
   end
 
   def entity_parameters
-    permitted = current_user_has_privilege?(:moderator, nil) ? Comment.administrative_parameters : Comment.entity_parameters
-    params.require(:comment).permit(permitted)
+    params.require(:comment).permit(Comment.entity_parameters)
   end
 
   def creation_parameters
-    params.require(:comment).permit(Comment.creation_parameters).merge(owner_for_entity(true))
+    permitted = Comment.creation_parameters
+    params.require(:comment).permit(permitted).merge(owner_for_entity(true))
   end
 
   def notify_participants
-    commentable = @entity.commentable
-    unless commentable.owned_by?(current_user)
-      category = Notification.category_from_object(commentable)
-      Notification.notify(commentable.user, category, commentable.id)
-      # begin
-      #   Comments.entry_reply(@entity).deliver_now if @entity.notify_entry_owner?
-      # rescue Net::SMTPAuthenticationError => error
-      #   logger.warn error.message
-      # end
-    end
+    # to be implemented...
   end
 end

data/app/helpers/comments_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Helper methods for handling comments
+module CommentsHelper
+  # @param [Comment] entity
+  # @param [String] text
+  # @param [Hash] options
+  def admin_comment_link(entity, text = entity.text_for_link, options = {})
+    link_to(text, admin_comment_path(id: entity.id), options)
+  end
+
+  # @param [Comment] entity
+  # @param [String] text
+  # @param [Hash] options
+  def comment_link(entity, text = entity.commentable_name, options = {})
+    anchor = options.key?(:anchor)
+    options.delete(:anchor)
+    link_to(text, CommentsManager.commentable_path(entity, anchor), options)
+  end
+end

data/app/models/comment.rb

@@ -1,53 +1,103 @@
+# frozen_string_literal: true
+
+# Comment
+#
+# Attributes:
+#   agent_id [Agent], optional
+#   approved [Boolean]
+#   author_email [String], optional
+#   author_name [String], optional
+#   body [Text]
+#   commentable_id [Integer]
+#   commentable_type [String]
+#   created_at [DateTime]
+#   deleted [Boolean]
+#   downvote_count [Integer]
+#   ip [Inet], optional
+#   locked [Boolean]
+#   parent_id [Comment], optional
+#   spam [Boolean]
+#   updated_at [DateTime]
+#   upvote_count [Integer]
+#   visible [Boolean]
+#   vote_result [Integer]
 class Comment < ApplicationRecord
+  include Checkable
   include HasOwner
   include Toggleable
-  include VotableItem
+  include VotableItem if Gem.loaded_specs.key?('biovision-vote')
 
-  PER_PAGE = 20
+  AUTHOR_LIMIT = 100
+  BODY_LIMIT = 1_048_576
 
   toggleable :visible
 
-  belongs_to :user, optional: true, counter_cache: true, touch: false
+  belongs_to :user, optional: true
   belongs_to :agent, optional: true
   belongs_to :commentable, polymorphic: true, counter_cache: true, touch: false
+  belongs_to :parent, class_name: Comment.to_s, optional: true
+  has_many :child_comments, class_name: Comment.to_s, foreign_key: :parent_id, dependent: :destroy
 
   validates_presence_of :body
+  validates_length_of :body, maximum: BODY_LIMIT
+  validates_length_of :author_name, maximum: AUTHOR_LIMIT
+  validates_length_of :author_email, maximum: AUTHOR_LIMIT
   validate :commentable_is_commentable
 
+  after_create { commentable.comment_impact(self) if commentable.respond_to?(:comment_impact) }
+
   scope :recent, -> { order 'id desc' }
-  scope :visible, -> { where(deleted: false, visible: true) }
+  scope :chronological, -> { order 'id asc' }
+  scope :visible, -> { where(deleted: false, visible: true, spam: false) } #, approved: true) }
+  scope :list_for_administration, -> { recent }
+  scope :list_for_visitors, -> { visible.chronological }
+  scope :list_for_visitors_recent, -> { visible.recent }
+  scope :list_for_owner, ->(v) { owned_by(v).where(deleted: false).recent }
 
   # @param [Integer] page
-  def self.page_for_administration(page)
-    recent.page(page).per(PER_PAGE)
+  def self.page_for_administration(page = 1)
+    list_for_administration.page(page)
   end
 
   # @param [Integer] page
-  def self.page_for_visitor(page)
-    recent.visible.page(page).per(PER_PAGE)
+  def self.page_for_visitor(page = 1)
+    list_for_visitors.page(page)
   end
 
   # @param [User] user
   # @param [Integer] page
-  def self.page_for_owner(user, page)
-    owned_by(user).where(deleted: false).recent.page(page).per(PER_PAGE)
+  def self.page_for_owner(user, page = 1)
+    list_for_owner(user).page(page)
   end
 
   def self.entity_parameters
-    %i(body)
+    %i[author_name author_email body]
   end
 
   def self.creation_parameters
-    entity_parameters + %i(commentable_id commentable_type)
+    entity_parameters + %i[commentable_id commentable_type parent_id]
   end
 
   def self.administrative_parameters
-    entity_parameters + %i(deleted)
+    entity_parameters + %i[deleted visible spam]
+  end
+
+  def self.tree(collection)
+    result = {}
+
+    collection.each do |entity|
+      result[entity.id] = {
+        parent_id: entity.parent_id,
+        comment: entity,
+      }
+    end
+
+    result
   end
 
   # @param [User] user
   def visible_to?(user)
-    if self.commentable.respond_to? :visible_to?
+    if commentable.respond_to? :visible_to?
       if deleted?
         UserPrivilege.user_has_privilege?(user, :administrator) && commentable.visible_to?(user)
       else
@@ -67,13 +117,32 @@ class Comment < ApplicationRecord
     end
   end
 
+  def text_for_link
+    "#{self.class.model_name.human} #{id}"
+  end
+
+  def commentable_name
+    "#{commentable.class.model_name.human} #{commentable_id}"
+  end
+
+  def commentable_title
+    if commentable.respond_to?(:title)
+      commentable.title
+    else
+      commentable_name
+    end
+  end
+
+  def profile_name
+    user.nil? ? author_name : user.profile_name
+  end
+
   private
 
   def commentable_is_commentable
-    if self.commentable.respond_to? :commentable_by?
-      unless self.commentable.commentable_by? self.user
-        errors.add(:commentable, I18n.t('activerecord.errors.models.comment.attributes.commentable.not_commentable'))
-      end
-    end
+    return unless commentable.respond_to?(:commentable_by?)
+    return if commentable.commentable_by?(user)
+
+    errors.add(:commentable, I18n.t('activerecord.errors.models.comment.attributes.commentable.not_commentable'))
   end
 end

data/app/models/concerns/commentable_item.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Adds "commentable" behavior to entity
+module CommentableItem
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :comments, as: :commentable, dependent: :destroy
+  end
+
+  # @param [User] user
+  def commentable_by?(user)
+    !user.nil?
+  end
+end

data/app/services/biovision/components/comments_component.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    # Handler for Biovision Comments
+    class CommentsComponent < BaseComponent
+      SLUG = 'comments'
+
+      def self.privilege_names
+        %w[moderator]
+      end
+
+      def use_parameters?
+        false
+      end
+
+      # @param [Hash] parameters
+      def create_comment(parameters)
+        @comment = ::Comment.new(parameters)
+        @comment.save
+        @comment
+      end
+
+      protected
+
+      # @param [Hash] data
+      # @return [Hash]
+      def normalize_settings(data)
+        result = {}
+        flags  = %w[premoderation]
+        flags.each { |f| result[f] = data[f].to_i == 1 }
+        numbers = %w[auto_approve_threshold]
+        numbers.each { |f| result[f] = data[f].to_i }
+
+        result
+      end
+    end
+  end
+end

data/app/services/comment_handler.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Handler for working with comments
+class CommentHandler
+  attr_accessor :user
+
+  # @param [User] user
+  def initialize(user = nil)
+    slug = Biovision::Components::CommentsComponent::SLUG
+    @user = user
+    @handler = Biovision::Components::BaseComponent.handler(slug)
+  end
+
+  # Get list of comments for entity
+  #
+  # Depending on privileges, receives list for visitors (only visible
+  # and approved) or all comments (including deleted).
+  #
+  # @param [ApplicationRecord] entity
+  def list(entity)
+    if @handler.class.allow?(@user)
+      entity.comments.list_for_administration
+    else
+      entity.comments.list_for_visitors
+    end
+  end
+
+  # Auto-approve comment from current user?
+  #
+  # If premoderation flag is not set, every comment is automatically approved.
+  # If premoderation flag is set, difference between approved and non-approved
+  # comments must be more than threshold; anonymous comments are always
+  # non-approved.
+  def approve?
+    return true unless @component.settings['premoderate']
+    return false if @user.nil?
+    return true if @component.class.allow?(@user)
+
+    gate = @component.settings['auto_approve_threshold'].to_i
+    positive = Comment.where(user: @user, approved: true).count
+    negative = Comment.where(user: @user, approved: false).count
+    positive - negative >= gate
+  end
+
+  # @param [ApplicationRecord] entity
+  def allow_reply?(entity)
+    entity.respond_to?(:commentable_by?) && entity.commentable_by?(@user)
+  end
+end

data/app/services/comments_manager.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Tool for handling comments
+class CommentsManager
+  # @param [Comment] comment
+  # @param [TrueClass|FalseClass] anchor
+  def self.commentable_path(comment, anchor = false)
+    method_name = "#{comment.commentable_type}_path".downcase.to_sym
+    if respond_to?(method_name)
+      result = send(method_name, comment.commentable)
+      anchor ? "#{result}#comment-#{comment.id}" : result
+    else
+      "##{method_name}"
+    end
+  end
+
+  # @param [Post] entity
+  def self.post_path(entity)
+    return '#post' unless Gem.loaded_specs.key?('biovision-post')
+
+    handler = PostManager.new(entity)
+    handler.post_path
+  end
+end

data/app/views/admin/comments/entity/_in_list.html.erb

@@ -6,23 +6,26 @@
     <%= admin_comment_link(entity) %>
 
     <% if entity.deleted? %>
-        (<%= t('activerecord.attributes.comment.deleted') %>)
+      (<%= t('activerecord.attributes.comment.deleted') %>)
     <% end %>
   </div>
 
   <div class="info">
+    <%= entity.commentable_name %>
+    (<%= entity.commentable_title %>)<br/>
     <%= admin_user_link(entity.user) %>,
     <%= time_tag entity.created_at %>
   </div>
 
-  <div class="info">
-    <%= prepare_comment_text(entity) %>
+  <div class="secondary info">
+    <%= simple_format(entity.body) %>
   </div>
 
   <ul class="actions">
-    <li><%= edit_icon(edit_comment_path(entity.id)) %></li>
+    <li><%= edit_icon(edit_comment_path(id: entity.id)) %></li>
     <% unless entity.deleted? %>
-        <li class="danger"><%= destroy_icon(entity) %></li>
+      <li><%= world_icon(CommentsManager.commentable_path(entity, true)) %></li>
+      <li class="danger"><%= destroy_icon(entity) %></li>
     <% end %>
   </ul>
 </div>