decidim 0.0.1 → 0.0.2

data/decidim-comments/app/frontend/comments/vote_button_component.test.jsx

@@ -0,0 +1,38 @@
+/* eslint-disable no-unused-expressions */
+import { shallow } from 'enzyme';
+
+import VoteButton  from './vote_button.component';
+import Icon        from '../application/icon.component';
+
+import stubComponent from '../support/stub_component';
+
+describe("<VoteButton />", () => {
+  const voteAction = sinon.spy();
+  stubComponent(Icon);
+
+  it("should render the number of votes passed as a prop", () => {
+    const wrapper = shallow(<VoteButton votes={10} buttonClassName="vote-button" iconName="vote-icon" voteAction={voteAction} />);
+    expect(wrapper.find('button')).to.include.text(10);
+  });
+
+  it("should render a button with the given buttonClassName", () => {
+    const wrapper = shallow(<VoteButton votes={10} buttonClassName="vote-button" iconName="vote-icon" voteAction={voteAction} />);
+    expect(wrapper.find('button.vote-button')).to.be.present();
+  });
+
+  it("should render a Icon component with the correct name prop", () => {
+    const wrapper = shallow(<VoteButton votes={10} buttonClassName="vote-button" iconName="vote-icon" voteAction={voteAction} />); 
+    expect(wrapper.find(Icon)).to.have.prop("name").equal('vote-icon');
+  });
+
+  it("should call the voteAction prop on click", () => {
+    const wrapper = shallow(<VoteButton votes={10} buttonClassName="vote-button" iconName="vote-icon" voteAction={voteAction} />);
+    wrapper.find('button').simulate('click');
+    expect(voteAction).to.have.been.called;
+  });
+
+  it("should disable the button based on the disabled prop", () => {
+    const wrapper = shallow(<VoteButton votes={10} buttonClassName="vote-button" iconName="vote-icon" voteAction={voteAction} disabled />);    
+    expect(wrapper.find('button')).to.be.disabled();
+  })
+});

data/decidim-comments/app/frontend/support/generate_comments_data.js

@@ -12,14 +12,19 @@ const generateCommentsData = (num = 1) => {
     commentsData.push({
       id: random.uuid(),
       body: random.words(),
-      createdAt: date.past().toString(),
+      createdAt: date.past().toISOString(),
       author: {
         name: name.findName(),
         avatarUrl: image.imageUrl()
       },
+      hasReplies: false,
       replies: [],
       canHaveReplies: true,
-      alignment: 0
+      alignment: 0,
+      upVotes: random.number(),
+      upVoted: false,
+      downVotes: random.number(),
+      downVoted: false
     })
   }
 

data/decidim-comments/app/helpers/decidim/comments/comments_helper.rb

@@ -18,7 +18,7 @@ module Decidim
 
         react_comments_component(node_id, commentableType: commentable_type,
                                           commentableId: commentable_id,
-                                          options: options.slice(:arguable),
+                                          options: options.slice(:arguable, :votable),
                                           locale: I18n.locale)
       end
 

data/decidim-comments/app/models/decidim/comments/application_record.rb

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

data/decidim-comments/app/models/decidim/comments/comment.rb

@@ -13,10 +13,11 @@ module Decidim
       #       |--R (depth 3)
       MAX_DEPTH = 3
 
-      belongs_to :author, class_name: Decidim::User
-      belongs_to :commentable, polymorphic: true
-      has_many :replies, as: :commentable, class_name: Comment
-
+      belongs_to :author, foreign_key: "decidim_author_id", class_name: Decidim::User
+      belongs_to :commentable, foreign_key: "decidim_commentable_id", foreign_type: "decidim_commentable_type", polymorphic: true
+      has_many :replies, as: :commentable, foreign_key: "decidim_commentable_id", foreign_type: "decidim_commentable_type", class_name: Comment
+      has_many :up_votes, -> { where(weight: 1) }, foreign_key: "decidim_comment_id", class_name: CommentVote, dependent: :destroy
+      has_many :down_votes, -> { where(weight: -1) }, foreign_key: "decidim_comment_id", class_name: CommentVote, dependent: :destroy
       validates :author, :commentable, :body, presence: true
       validate :commentable_can_have_replies
       validates :depth, numericality: { greater_than_or_equal_to: 0 }
@@ -34,6 +35,20 @@ module Decidim
         depth < MAX_DEPTH
       end
 
+      # Public: Check if the user has upvoted the comment
+      #
+      # Returns a bool value to indicate if the condition is truthy or not
+      def up_voted_by?(user)
+        up_votes.any? { |vote| vote.author == user }
+      end
+
+      # Public: Check if the user has downvoted the comment
+      #
+      # Returns a bool value to indicate if the condition is truthy or not
+      def down_voted_by?(user)
+        down_votes.any? { |vote| vote.author == user }
+      end
+
       private
 
       # Private: Check if commentable can have replies and if not adds

data/decidim-comments/app/models/decidim/comments/comment_vote.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Decidim
+  module Comments
+    # A comment can include user votes. A user should be able to upVote, votes with
+    # weight 1 and downVote, votes with weight -1.
+    class CommentVote < ApplicationRecord
+      belongs_to :comment, foreign_key: "decidim_comment_id", class_name: Comment
+      belongs_to :author, foreign_key: "decidim_author_id", class_name: Decidim::User
+
+      validates :comment, uniqueness: { scope: :author }
+      validates :weight, inclusion: { in: [-1, 1] }
+      validate :author_and_comment_same_organization
+
+      private
+
+      # Private: check if the comment and the author have the same organization
+      def author_and_comment_same_organization
+        errors.add(:comment, :invalid) unless author.organization == comment.organization
+      end
+    end
+  end
+end

data/decidim-comments/app/models/decidim/comments/seed.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Decidim
+  module Comments
+    # A comment can belong to many Commentable models. This class is responsible
+    # to Seed those models in order to be able to use them in the development
+    # app.
+    class Seed
+      # Public: adds a random amount of comments for a given resource.
+      #
+      # resource - the resource to add the coments to.
+      #
+      # Returns nothing.
+      def self.comments_for(resource)
+        organization = resource.organization
+
+        rand(1..5).times do
+          random = rand(Decidim::User.count)
+          Comment.create(
+            commentable: resource,
+            body: ::Faker::Lorem.sentence,
+            author: Decidim::User.where(organization: organization).offset(random).first
+          )
+        end
+      end
+    end
+  end
+end

data/decidim-comments/app/queries/decidim/comments/comments_with_replies.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+module Decidim
+  module Comments
+    # A class used to find comments for a commentable resource
+    class CommentsWithReplies < Rectify::Query
+      attr_reader :commentable
+
+      # Syntactic sugar to initialize the class and return the queried objects.
+      #
+      # commentable - a resource that can have comments
+      # options - The Hash options is used to refine the selection ( default: {}):
+      #           :order_by - The string order_by to sort by ( optional )
+      def self.for(commentable, options = {})
+        new(commentable, options).query
+      end
+
+      # Initializes the class.
+      #
+      # commentable = a resource that can have comments
+      # options - The Hash options is used to refine the selection ( default: {}):
+      #           :order_by - The string order_by to sort by ( optional )
+      def initialize(commentable, options = {})
+        options[:order_by] ||= "older"
+        @commentable = commentable
+        @options = options
+      end
+
+      # Finds the Comments for a resource that can have comments and eager
+      # loads comments replies. It uses Comment's MAX_DEPTH to load a maximum
+      # level of nested replies.
+      def query
+        scope = Comment
+                .where(commentable: commentable)
+                .includes(:author, :up_votes, :down_votes)
+                .includes(
+                  replies: [:author, :up_votes, :down_votes,
+                            replies: [:author, :up_votes, :down_votes,
+                                      replies: [:author, :up_votes, :down_votes]]]
+                )
+
+        scope = case @options[:order_by]
+                when "older"
+                  order_by_older(scope)
+                when "recent"
+                  order_by_recent(scope)
+                when "best_rated"
+                  order_by_best_rated(scope)
+                when "most_discussed"
+                  order_by_most_discussed(scope)
+                else
+                  order_by_older(scope)
+                end
+
+        scope
+      end
+
+      private
+
+      def order_by_older(scope)
+        scope.order(created_at: :asc)
+      end
+
+      def order_by_recent(scope)
+        scope.order(created_at: :desc)
+      end
+
+      def order_by_best_rated(scope)
+        scope.sort_by do |comment|
+          comment.up_votes.size - comment.down_votes.size
+        end.reverse
+      end
+
+      def order_by_most_discussed(scope)
+        scope.sort_by do |comment|
+          count_replies(comment)
+        end.reverse
+      end
+
+      def count_replies(comment)
+        if comment.replies.size.positive?
+          comment.replies.size + comment.replies.map { |reply| count_replies(reply) }.sum
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/decidim-comments/app/resolvers/decidim/comments/vote_comment_resolver.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module Decidim
+  module Comments
+    # A GraphQL resolver to handle `upVote` and `downVote` mutations
+    # It creates a vote for a comment by the current user.
+    class VoteCommentResolver
+      def initialize(options = { weight: 1 })
+        @weight = options[:weight]
+      end
+
+      def call(obj, _args, ctx)
+        Decidim::Comments::VoteComment.call(obj, ctx[:current_user], weight: @weight) do
+          on(:ok) do |comment|
+            return comment
+          end
+        end
+      end
+    end
+  end
+end

data/decidim-comments/app/types/decidim/comments/comment_mutation_type.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Decidim
+  module Comments
+    CommentMutationType = GraphQL::ObjectType.define do
+      name "CommentMutation"
+      description "A comment which includes its available mutations"
+
+      field :id, !types.ID, "The Comment's unique ID"
+
+      field :upVote, Decidim::Comments::CommentType do
+        resolve VoteCommentResolver.new(weight: 1)
+      end
+
+      field :downVote, Decidim::Comments::CommentType do
+        resolve VoteCommentResolver.new(weight: -1)
+      end
+    end
+  end
+end

data/decidim-comments/app/types/decidim/comments/comment_type.rb

@@ -11,18 +11,54 @@ module Decidim
       field :body, !types.String, "The comment message"
 
       field :createdAt, !types.String, "The creation date of the comment" do
-        property :created_at
+        resolve lambda { |obj, _args, _ctx|
+          obj.created_at.iso8601
+        }
       end
 
       field :author, !AuthorType, "The comment's author"
 
-      field :replies, !types[CommentType], "The comment's replies"
+      field :replies, !types[CommentType], "The comment's replies" do
+        resolve lambda { |obj, _args, _ctx|
+          obj.replies.sort_by(&:created_at)
+        }
+      end
+
+      field :hasReplies, !types.Boolean, "Check if the comment has replies" do
+        resolve lambda { |obj, _args, _ctx|
+          obj.replies.size.positive?
+        }
+      end
 
       field :canHaveReplies, !types.Boolean, "Define if a comment can or not have replies" do
         property :can_have_replies?
       end
 
       field :alignment, types.Int, "The comment's alignment. Can be 0 (neutral), 1 (in favor) or -1 (against)'"
+
+      field :upVotes, !types.Int, "The number of comment's upVotes" do
+        resolve lambda { |obj, _args, _ctx|
+          obj.up_votes.size
+        }
+      end
+
+      field :upVoted, !types.Boolean, "Check if the current user has upvoted the comment" do
+        resolve lambda { |obj, _args, ctx|
+          obj.up_voted_by?(ctx[:current_user])
+        }
+      end
+
+      field :downVotes, !types.Int, "The number of comment's downVotes" do
+        resolve lambda { |obj, _args, _ctx|
+          obj.down_votes.size
+        }
+      end
+
+      field :downVoted, !types.Boolean, "Check if the current user has downvoted the comment" do
+        resolve lambda { |obj, _args, ctx|
+          obj.down_voted_by?(ctx[:current_user])
+        }
+      end
     end
   end
 end

data/decidim-comments/config/locales/en.yml

@@ -31,6 +31,7 @@ en:
       comment_thread:
         title: Conversation with %{authorName}
       comments:
+        loading: Loading comments ...
         title: "%{count} comments"
       featured_comment:
         title: Featured comment

data/decidim-comments/db/migrate/20161130143508_create_comments.rb

@@ -2,10 +2,12 @@ class CreateComments < ActiveRecord::Migration[5.0]
   def change
     create_table :decidim_comments_comments do |t|
       t.text :body, null: false
-      t.references :commentable, null: false, polymorphic: true, index: { name: "decidim_comments_comment_commentable" }
-      t.references :author, null: false, index: { name: "decidim_comments_comment_author" }
+      t.references :decidim_commentable, null: false, polymorphic: true, index: { name: "decidim_comments_comment_commentable" }
+      t.references :decidim_author, null: false, index: { name: "decidim_comments_comment_author" }
 
       t.timestamps
     end
+
+    add_index :decidim_comments_comments, :created_at
   end
 end

data/decidim-comments/db/migrate/20161219150806_create_comment_votes.rb

@@ -0,0 +1,13 @@
+class CreateCommentVotes < ActiveRecord::Migration[5.0]
+  def change
+    create_table :decidim_comments_comment_votes do |t|
+      t.integer :weight, null: false
+      t.references :decidim_comment, null: false, index: { name: "decidim_comments_comment_vote_comment" }
+      t.references :decidim_author, null: false, index: { name: "decidim_comments_comment_vote_author" }
+      
+      t.timestamps
+    end
+
+    add_index :decidim_comments_comment_votes, [:decidim_comment_id, :decidim_author_id], unique: true, name: "decidim_comments_comment_vote_comment_author_unique"
+  end
+end

data/decidim-comments/decidim-comments.gemspec

@@ -15,11 +15,8 @@ Gem::Specification.new do |s|
 
   s.add_dependency "decidim-core", Decidim.version
   s.add_dependency "rails", *Decidim.rails_version
-  s.add_dependency "foundation-rails", "~> 6.2.4.0"
-  s.add_dependency "sassc-rails", "~> 1.3.0"
   s.add_dependency "jquery-rails", "~> 4.0"
   s.add_dependency "turbolinks", *Decidim.rails_version
-  s.add_dependency "foundation_rails_helper", "~> 2.0.0"
 
   s.add_development_dependency "decidim-dev", Decidim.version
 end

data/decidim-comments/lib/decidim/comments/mutation_extensions.rb

@@ -29,6 +29,15 @@ module Decidim
               end
             }
           end
+
+          field :comment, Decidim::Comments::CommentMutationType do
+            description "A comment"
+            argument :id, !types.ID, "The comment's id"
+
+            resolve lambda { |_obj, args, _ctx|
+              Comment.find(args["id"])
+            }
+          end
         end
       end
     end

data/decidim-comments/lib/decidim/comments/query_extensions.rb

@@ -17,13 +17,11 @@ module Decidim
 
             argument :commentableId, !types.String, "The commentable's ID"
             argument :commentableType, !types.String, "The commentable's class name. i.e. `Decidim::ParticipatoryProcess`"
+            argument :orderBy, types.String, "Order the comments"
 
             resolve lambda { |_obj, args, _ctx|
-              Comment
-                .where(commentable_id: args[:commentableId])
-                .where(commentable_type: args[:commentableType])
-                .order(created_at: :asc)
-                .all
+              commentable = args[:commentableType].constantize.find(args[:commentableId])
+              CommentsWithReplies.for(commentable, order_by: args[:orderBy])
             }
           end
         end