407 lines
10 KiB
Ruby
407 lines
10 KiB
Ruby
class Comment < ActiveRecord::Base
|
|
belongs_to :user
|
|
belongs_to :story
|
|
has_many :votes,
|
|
:dependent => :delete_all
|
|
belongs_to :parent_comment,
|
|
:class_name => "Comment"
|
|
has_one :moderation,
|
|
:class_name => "Moderation"
|
|
|
|
attr_accessible :comment, :moderation_reason
|
|
|
|
attr_accessor :parent_comment_short_id, :current_vote, :previewing,
|
|
:indent_level, :highlighted
|
|
|
|
before_create :assign_short_id_and_upvote, :assign_initial_confidence,
|
|
:assign_thread_id
|
|
after_create :assign_votes, :mark_submitter, :deliver_reply_notifications,
|
|
:deliver_mention_notifications
|
|
after_destroy :unassign_votes
|
|
|
|
MAX_EDIT_MINS = 45
|
|
|
|
define_index do
|
|
indexes comment
|
|
indexes user.username, :as => :author
|
|
|
|
has "(upvotes - downvotes)", :as => :score, :type => :integer,
|
|
:sortable => true
|
|
|
|
has is_deleted
|
|
has created_at
|
|
|
|
where "is_deleted = 0 AND is_moderated = 0"
|
|
end
|
|
|
|
validate do
|
|
self.comment.to_s.strip == "" &&
|
|
errors.add(:comment, "cannot be blank.")
|
|
|
|
self.user_id.blank? &&
|
|
errors.add(:user_id, "cannot be blank.")
|
|
|
|
self.story_id.blank? &&
|
|
errors.add(:story_id, "cannot be blank.")
|
|
|
|
(m = self.comment.to_s.strip.match(/\A(t)his([\.!])?$\z/i)) &&
|
|
errors.add(:base, (m[1] == "T" ? "N" : "n") + "ope" + m[2].to_s)
|
|
end
|
|
|
|
def self.regenerate_markdown
|
|
Comment.record_timestamps = false
|
|
|
|
Comment.all.each do |c|
|
|
c.markeddown_comment = c.generated_markeddown_comment
|
|
c.save(:validate => false)
|
|
end
|
|
|
|
Comment.record_timestamps = true
|
|
|
|
nil
|
|
end
|
|
|
|
def as_json(options = {})
|
|
h = super(:only => [
|
|
:short_id,
|
|
:created_at,
|
|
:updated_at,
|
|
:is_deleted,
|
|
:is_moderated,
|
|
])
|
|
h[:score] = score
|
|
|
|
if self.is_gone?
|
|
h[:comment] = "<em>#{self.gone_text}</em>"
|
|
else
|
|
h[:comment] = markeddown_comment
|
|
end
|
|
|
|
h[:url] = url
|
|
h[:indent_level] = indent_level
|
|
h[:commenting_user] = user
|
|
h
|
|
end
|
|
|
|
def assign_short_id_and_upvote
|
|
self.short_id = ShortId.new(self.class).generate
|
|
self.upvotes = 1
|
|
end
|
|
|
|
def assign_votes
|
|
Vote.vote_thusly_on_story_or_comment_for_user_because(1, self.story_id,
|
|
self.id, self.user.id, nil, false)
|
|
|
|
self.story.update_comment_count!
|
|
end
|
|
|
|
def vote_summary
|
|
r_counts = {}
|
|
Vote.where(:comment_id => self.id).each do |v|
|
|
r_counts[v.reason.to_s] ||= 0
|
|
r_counts[v.reason.to_s] += v.vote
|
|
end
|
|
|
|
r_counts.keys.sort.map{|k|
|
|
k == "" ? "+#{r_counts[k]}" : "#{r_counts[k]} #{Vote::COMMENT_REASONS[k]}"
|
|
}.join(", ")
|
|
end
|
|
|
|
def is_gone?
|
|
is_deleted? || is_moderated?
|
|
end
|
|
|
|
def gone_text
|
|
if self.is_moderated?
|
|
"Thread removed by moderator " <<
|
|
self.moderation.try(:moderator).try(:username).to_s << ": " <<
|
|
(self.moderation.try(:reason) || "No reason given")
|
|
else
|
|
"Comment removed by author"
|
|
end
|
|
end
|
|
|
|
def mark_submitter
|
|
Keystore.increment_value_for("user:#{self.user_id}:comments_posted")
|
|
end
|
|
|
|
def deliver_mention_notifications
|
|
self.plaintext_comment.scan(/\B\@([\w\-]+)/).flatten.uniq.each do |mention|
|
|
if u = User.find_by_username(mention)
|
|
if u.id == self.user.id
|
|
next
|
|
end
|
|
|
|
begin
|
|
if u.email_mentions?
|
|
EmailReply.mention(self, u).deliver
|
|
end
|
|
|
|
if u.pushover_mentions? && u.pushover_user_key.present?
|
|
Pushover.push(u.pushover_user_key, u.pushover_device, {
|
|
:title => "Lobsters mention by #{self.user.username} on " <<
|
|
self.story.title,
|
|
:message => self.plaintext_comment,
|
|
:url => self.url,
|
|
:url_title => "Reply to #{self.user.username}",
|
|
})
|
|
end
|
|
rescue => e
|
|
Rails.logger.error "failed to deliver mention notification to " <<
|
|
"#{u.username}: #{e.message}"
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def deliver_reply_notifications
|
|
if self.parent_comment_id && (u = self.parent_comment.try(:user)) &&
|
|
u.id != self.user.id
|
|
begin
|
|
if u.email_replies?
|
|
EmailReply.reply(self, u).deliver
|
|
end
|
|
|
|
if u.pushover_replies? && u.pushover_user_key.present?
|
|
Pushover.push(u.pushover_user_key, u.pushover_device, {
|
|
:title => "Lobsters reply from #{self.user.username} on " <<
|
|
"#{self.story.title}",
|
|
:message => self.plaintext_comment,
|
|
:url => self.url,
|
|
:url_title => "Reply to #{self.user.username}",
|
|
})
|
|
end
|
|
rescue => e
|
|
Rails.logger.error "failed to deliver reply notification to " <<
|
|
"#{u.username}: #{e.message}"
|
|
end
|
|
end
|
|
end
|
|
|
|
def delete_for_user(user)
|
|
Comment.record_timestamps = false
|
|
|
|
self.is_deleted = true
|
|
|
|
if user.is_moderator? && user.id != self.user_id
|
|
self.is_moderated = true
|
|
|
|
m = Moderation.new
|
|
m.comment_id = self.id
|
|
m.moderator_user_id = user.id
|
|
m.action = "deleted comment"
|
|
m.save
|
|
end
|
|
|
|
self.save(:validate => false)
|
|
Comment.record_timestamps = true
|
|
|
|
self.story.update_comment_count!
|
|
end
|
|
|
|
def undelete_for_user(user)
|
|
Comment.record_timestamps = false
|
|
|
|
self.is_deleted = false
|
|
|
|
if user.is_moderator?
|
|
self.is_moderated = false
|
|
|
|
if user.id != self.user_id
|
|
m = Moderation.new
|
|
m.comment_id = self.id
|
|
m.moderator_user_id = user.id
|
|
m.action = "undeleted comment"
|
|
m.save
|
|
end
|
|
end
|
|
|
|
self.save(:validate => false)
|
|
Comment.record_timestamps = true
|
|
|
|
self.story.update_comment_count!
|
|
end
|
|
|
|
def give_upvote_or_downvote_and_recalculate_confidence!(upvote, downvote)
|
|
self.upvotes += upvote.to_i
|
|
self.downvotes += downvote.to_i
|
|
|
|
Comment.connection.execute("UPDATE #{Comment.table_name} SET " <<
|
|
"upvotes = COALESCE(upvotes, 0) + #{upvote.to_i}, " <<
|
|
"downvotes = COALESCE(downvotes, 0) + #{downvote.to_i}, " <<
|
|
"confidence = '#{self.calculated_confidence}' WHERE id = " <<
|
|
"#{self.id.to_i}")
|
|
end
|
|
|
|
# http://evanmiller.org/how-not-to-sort-by-average-rating.html
|
|
# https://github.com/reddit/reddit/blob/master/r2/r2/lib/db/_sorts.pyx
|
|
def calculated_confidence
|
|
n = (upvotes + downvotes).to_f
|
|
if n == 0.0
|
|
return 0
|
|
end
|
|
|
|
z = 1.281551565545 # 80% confidence
|
|
p = upvotes.to_f / n
|
|
|
|
left = p + (1 / ((2.0 * n) * z * z))
|
|
right = z * Math.sqrt((p * ((1.0 - p) / n)) + (z * (z / (4.0 * n * n))))
|
|
under = 1.0 + ((1.0 / n) * z * z)
|
|
|
|
return (left - right) / under
|
|
end
|
|
|
|
def assign_initial_confidence
|
|
self.confidence = self.calculated_confidence
|
|
end
|
|
|
|
def assign_thread_id
|
|
if self.parent_comment_id.present?
|
|
self.thread_id = self.parent_comment.thread_id
|
|
else
|
|
self.thread_id = Keystore.incremented_value_for("thread_id")
|
|
end
|
|
end
|
|
|
|
def unassign_votes
|
|
self.story.update_comment_count!
|
|
end
|
|
|
|
def score
|
|
self.upvotes - self.downvotes
|
|
end
|
|
|
|
def generated_markeddown_comment
|
|
Markdowner.to_html(self.comment)
|
|
end
|
|
|
|
def comment=(com)
|
|
self[:comment] = com.to_s.rstrip
|
|
self.markeddown_comment = self.generated_markeddown_comment
|
|
end
|
|
|
|
def has_been_edited?
|
|
self.updated_at && (self.updated_at - self.created_at > 1.minute)
|
|
end
|
|
|
|
def mailing_list_message_id
|
|
"comment.#{short_id}.#{created_at.to_i}@lobste.rs"
|
|
end
|
|
|
|
def plaintext_comment
|
|
# TODO: linkify then strip tags and convert entities back
|
|
comment
|
|
end
|
|
|
|
def self.ordered_for_story_or_thread_for_user(story_id, thread_id, user)
|
|
parents = {}
|
|
|
|
if thread_id
|
|
cs = [ "thread_id = ?", thread_id ]
|
|
else
|
|
cs = [ "story_id = ?", story_id ]
|
|
end
|
|
|
|
Comment.find(:all, :conditions => cs, :order => "confidence DESC",
|
|
:include => :user).each do |c|
|
|
(parents[c.parent_comment_id.to_i] ||= []).push c
|
|
end
|
|
|
|
# top-down list of comments, regardless of indent level
|
|
ordered = []
|
|
|
|
recursor = lambda{|comment,level|
|
|
if comment
|
|
comment.indent_level = level
|
|
ordered.push comment
|
|
end
|
|
|
|
# for each comment that is a child of this one, recurse with it
|
|
(parents[comment ? comment.id : 0] || []).each do |child|
|
|
recursor.call(child, level + 1)
|
|
end
|
|
}
|
|
recursor.call(nil, 0)
|
|
|
|
# for deleted comments, if they have no children, they can be removed from
|
|
# the tree. otherwise they have to stay and a "[deleted]" stub will be
|
|
# shown
|
|
new_ordered = []
|
|
ordered.each_with_index do |c,x|
|
|
if c.is_gone?
|
|
if ordered[x + 1] && (ordered[x + 1].indent_level > c.indent_level)
|
|
# we have child comments, so we must stay
|
|
elsif user && (user.is_moderator? || c.user_id == user.id)
|
|
# admins and authors should be able to see their deleted comments
|
|
else
|
|
# drop this one
|
|
next
|
|
end
|
|
end
|
|
|
|
new_ordered.push c
|
|
end
|
|
|
|
# for moderated threads, remove the entire sub-tree at the moderation point
|
|
do_reject = false
|
|
deleted_indent_level = 0
|
|
new_ordered.reject!{|c|
|
|
if do_reject && (c.indent_level > deleted_indent_level)
|
|
true
|
|
else
|
|
if c.is_moderated?
|
|
do_reject = true
|
|
deleted_indent_level = c.indent_level
|
|
else
|
|
do_reject = false
|
|
end
|
|
|
|
false
|
|
end
|
|
}
|
|
|
|
new_ordered
|
|
end
|
|
|
|
def is_editable_by_user?(user)
|
|
if user && user.id == self.user_id
|
|
if self.is_moderated?
|
|
return false
|
|
else
|
|
return (Time.now.to_i - (self.updated_at ? self.updated_at.to_i :
|
|
self.created_at.to_i) < (60 * MAX_EDIT_MINS))
|
|
end
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
def is_deletable_by_user?(user)
|
|
if user && user.is_moderator?
|
|
return true
|
|
elsif user && user.id == self.user_id
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
def is_undeletable_by_user?(user)
|
|
if user && user.is_moderator?
|
|
return true
|
|
elsif user && user.id == self.user_id && !self.is_moderated?
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
def short_id_url
|
|
self.story.short_id_url + "/_/comments/#{self.short_id}"
|
|
end
|
|
|
|
def url
|
|
self.story.comments_url + "/comments/#{self.short_id}"
|
|
end
|
|
end
|