discourse/app/models/badge.rb

444 lines
12 KiB
Ruby
Raw Normal View History

2014-03-05 07:52:20 -05:00
class Badge < ActiveRecord::Base
# badge ids
Welcome = 5
NicePost = 6
GoodPost = 7
GreatPost = 8
Autobiographer = 9
2014-07-07 03:55:25 -04:00
Editor = 10
FirstLike = 11
FirstShare = 12
FirstFlag = 13
2014-07-09 21:18:02 -04:00
FirstLink = 14
2014-07-11 00:17:01 -04:00
FirstQuote = 15
2014-07-16 02:26:22 -04:00
ReadGuidelines = 16
Reader = 17
NiceTopic = 18
GoodTopic = 19
GreatTopic = 20
NiceShare = 21
GoodShare = 22
GreatShare = 23
2015-02-18 13:30:07 -05:00
OneYearAnniversary = 24
2016-03-16 13:48:14 -04:00
Promoter = 25
Campaigner = 26
Champion = 27
2016-03-16 13:48:14 -04:00
PopularLink = 28
HotLink = 29
FamousLink = 30
2016-03-16 13:48:14 -04:00
2016-03-16 13:03:17 -04:00
Appreciated = 36
Respected = 37
Admired = 31
2016-03-16 13:48:14 -04:00
OutOfLove = 33
HigherLove = 34
CrazyInLove = 35
2016-03-16 13:48:14 -04:00
ThankYou = 38
GivesBack = 32
Empathetic = 39
# other consts
AutobiographerMinBioLength = 10
def self.trigger_hash
Hash[*(
Badge::Trigger.constants.map{|k|
[k.to_s.underscore, Badge::Trigger.const_get(k)]
}.flatten
)]
end
2014-07-21 22:46:31 -04:00
module Trigger
None = 0
PostAction = 1
PostRevision = 2
TrustLevelChange = 4
UserChange = 8
def self.is_none?(trigger)
[None].include? trigger
end
def self.uses_user_ids?(trigger)
[TrustLevelChange, UserChange].include? trigger
end
def self.uses_post_ids?(trigger)
[PostAction, PostRevision].include? trigger
end
end
module Queries
2014-07-11 03:32:29 -04:00
Reader = <<SQL
SELECT id user_id, current_timestamp granted_at
FROM users
WHERE id IN
(
SELECT pt.user_id
FROM post_timings pt
JOIN badge_posts b ON b.post_number = pt.post_number AND
b.topic_id = pt.topic_id
JOIN topics t ON t.id = pt.topic_id
LEFT JOIN user_badges ub ON ub.badge_id = 17 AND ub.user_id = pt.user_id
2014-07-18 01:57:03 -04:00
WHERE ub.id IS NULL AND t.posts_count > 100
GROUP BY pt.user_id, pt.topic_id, t.posts_count
HAVING count(*) >= t.posts_count
)
SQL
2014-07-16 02:26:22 -04:00
ReadGuidelines = <<SQL
SELECT user_id, read_faq granted_at
2014-07-11 03:35:34 -04:00
FROM user_stats
WHERE read_faq IS NOT NULL AND (user_id IN (:user_ids) OR :backfill)
2014-07-11 03:32:29 -04:00
SQL
2014-07-11 00:17:01 -04:00
FirstQuote = <<SQL
SELECT ids.user_id, q.post_id, q.created_at granted_at
2014-07-11 00:17:01 -04:00
FROM
(
SELECT p1.user_id, MIN(q1.id) id
FROM quoted_posts q1
JOIN badge_posts p1 ON p1.id = q1.post_id
JOIN badge_posts p2 ON p2.id = q1.quoted_post_id
WHERE (:backfill OR ( p1.id IN (:post_ids) ))
GROUP BY p1.user_id
2014-07-11 00:17:01 -04:00
) ids
JOIN quoted_posts q ON q.id = ids.id
2014-07-11 00:17:01 -04:00
SQL
2014-07-09 21:18:02 -04:00
FirstLink = <<SQL
SELECT l.user_id, l.post_id, l.created_at granted_at
FROM
(
SELECT MIN(l1.id) id
FROM topic_links l1
JOIN badge_posts p1 ON p1.id = l1.post_id
JOIN badge_posts p2 ON p2.id = l1.link_post_id
WHERE NOT reflection AND p1.topic_id <> p2.topic_id AND not quote AND
(:backfill OR ( p1.id in (:post_ids) ))
2014-07-09 21:18:02 -04:00
GROUP BY l1.user_id
) ids
JOIN topic_links l ON l.id = ids.id
SQL
FirstShare = <<SQL
SELECT views.user_id, i2.post_id, i2.created_at granted_at
FROM
(
SELECT i.user_id, MIN(i.id) i_id
FROM incoming_links i
JOIN badge_posts p on p.id = i.post_id
2014-07-09 21:18:02 -04:00
WHERE i.user_id IS NOT NULL
GROUP BY i.user_id
) as views
JOIN incoming_links i2 ON i2.id = views.i_id
SQL
FirstFlag = <<SQL
SELECT pa1.user_id, pa1.created_at granted_at, pa1.post_id
FROM (
SELECT pa.user_id, min(pa.id) id
FROM post_actions pa
JOIN badge_posts p on p.id = pa.post_id
WHERE post_action_type_id IN (#{PostActionType.flag_types.values.join(",")}) AND
(:backfill OR pa.post_id IN (:post_ids) )
GROUP BY pa.user_id
) x
JOIN post_actions pa1 on pa1.id = x.id
SQL
FirstLike = <<SQL
SELECT pa1.user_id, pa1.created_at granted_at, pa1.post_id
FROM (
SELECT pa.user_id, min(pa.id) id
FROM post_actions pa
JOIN badge_posts p on p.id = pa.post_id
WHERE post_action_type_id = 2 AND
(:backfill OR pa.post_id IN (:post_ids) )
GROUP BY pa.user_id
) x
JOIN post_actions pa1 on pa1.id = x.id
2014-07-08 00:26:53 -04:00
SQL
2014-07-07 03:55:25 -04:00
# Incorrect, but good enough - (earlies post edited vs first edit)
2014-07-07 03:55:25 -04:00
Editor = <<SQL
SELECT p.user_id, min(p.id) post_id, min(p.created_at) granted_at
2014-07-09 21:18:02 -04:00
FROM badge_posts p
WHERE p.self_edits > 0 AND
(:backfill OR p.id IN (:post_ids) )
2014-07-07 03:55:25 -04:00
GROUP BY p.user_id
SQL
Welcome = <<SQL
SELECT p.user_id, min(post_id) post_id, min(pa.created_at) granted_at
FROM post_actions pa
2014-07-09 21:18:02 -04:00
JOIN badge_posts p on p.id = pa.post_id
WHERE post_action_type_id = 2 AND
(:backfill OR pa.post_id IN (:post_ids) )
GROUP BY p.user_id
SQL
Autobiographer = <<SQL
SELECT u.id user_id, current_timestamp granted_at
FROM users u
JOIN user_profiles up on u.id = up.user_id
WHERE bio_raw IS NOT NULL AND LENGTH(TRIM(bio_raw)) > #{Badge::AutobiographerMinBioLength} AND
uploaded_avatar_id IS NOT NULL AND
(:backfill OR u.id IN (:user_ids) )
SQL
2015-02-18 13:30:07 -05:00
# member for a year + has posted at least once during that year
OneYearAnniversary = <<-SQL
SELECT u.id AS user_id, MIN(u.created_at + interval '1 year') AS granted_at
FROM users u
JOIN posts p ON p.user_id = u.id
WHERE u.id > 0
AND u.active
AND NOT u.blocked
AND u.created_at + interval '1 year' < now()
AND p.deleted_at IS NULL
AND NOT p.hidden
AND p.created_at + interval '1 year' > now()
AND (:backfill OR u.id IN (:user_ids))
GROUP BY u.id
HAVING COUNT(p.id) > 0
SQL
def self.invite_badge(count,trust_level)
"
SELECT u.id user_id, current_timestamp granted_at
FROM users u
WHERE u.id IN (
SELECT invited_by_id
FROM invites i
JOIN users u2 ON u2.id = i.user_id
WHERE i.deleted_at IS NULL AND u2.active AND u2.trust_level >= #{trust_level.to_i} AND not u2.blocked
GROUP BY invited_by_id
2015-10-12 21:32:29 -04:00
HAVING COUNT(*) >= #{count.to_i}
) AND u.active AND NOT u.blocked AND u.id > 0 AND
(:backfill OR u.id IN (:user_ids) )
"
end
def self.like_badge(count, is_topic)
# we can do better with dates, but its hard work
"
2014-07-09 21:18:02 -04:00
SELECT p.user_id, p.id post_id, p.updated_at granted_at
FROM badge_posts p
WHERE #{is_topic ? "p.post_number = 1" : "p.post_number > 1" } AND p.like_count >= #{count.to_i} AND
(:backfill OR p.id IN (:post_ids) )
"
end
def self.trust_level(level)
# we can do better with dates, but its hard work figuring this out historically
"
SELECT u.id user_id, current_timestamp granted_at FROM users u
WHERE trust_level >= #{level.to_i} AND (
:backfill OR u.id IN (:user_ids)
)
"
end
def self.sharing_badge(count)
<<SQL
SELECT views.user_id, i2.post_id, current_timestamp granted_at
FROM
(
SELECT i.user_id, MIN(i.id) i_id
FROM incoming_links i
JOIN badge_posts p on p.id = i.post_id
WHERE i.user_id IS NOT NULL
GROUP BY i.user_id,i.post_id
HAVING COUNT(*) > #{count}
) as views
JOIN incoming_links i2 ON i2.id = views.i_id
SQL
end
def self.linking_badge(count)
<<-SQL
SELECT tl.user_id, post_id, current_timestamp granted_at
FROM topic_links tl
JOIN posts p ON p.id = post_id AND p.deleted_at IS NULL
JOIN topics t ON t.id = p.topic_id AND t.deleted_at IS NULL AND t.archetype <> 'private_message'
WHERE NOT tl.internal
AND tl.clicks >= #{count}
GROUP BY tl.user_id, tl.post_id
SQL
end
2016-03-16 13:03:17 -04:00
def self.liked_posts(post_count, like_count)
<<-SQL
SELECT p.user_id, current_timestamp AS granted_at
FROM posts AS p
WHERE p.like_count >= #{like_count}
AND (:backfill OR p.user_id IN (:user_ids))
GROUP BY p.user_id
HAVING count(*) > #{post_count}
SQL
end
def self.like_rate_limit(count)
<<-SQL
SELECT gdl.user_id, current_timestamp AS granted_at
FROM given_daily_likes AS gdl
WHERE gdl.limit_reached
AND (:backfill OR gdl.user_id IN (:user_ids))
GROUP BY gdl.user_id
HAVING COUNT(*) >= #{count}
SQL
end
2016-03-16 13:48:14 -04:00
def self.liked_back(min_posts, ratio)
<<-SQL
SELECT p.user_id, current_timestamp AS granted_at
FROM posts AS p
INNER JOIN user_stats AS us ON us.user_id = p.user_id
WHERE p.like_count > 0
AND (:backfill OR p.user_id IN (:user_ids))
GROUP BY p.user_id, us.likes_given
HAVING count(*) > #{min_posts}
AND (us.likes_given / count(*)::float) > #{ratio}
SQL
end
end
2014-03-05 07:52:20 -05:00
belongs_to :badge_type
belongs_to :badge_grouping
has_many :user_badges, dependent: :destroy
2014-03-05 07:52:20 -05:00
validates :name, presence: true, uniqueness: true
validates :badge_type, presence: true
validates :allow_title, inclusion: [true, false]
2014-05-23 22:33:46 -04:00
validates :multiple_grant, inclusion: [true, false]
scope :enabled, ->{ where(enabled: true) }
before_create :ensure_not_system
# fields that can not be edited on system badges
def self.protected_system_fields
[:badge_type_id, :multiple_grant, :target_posts, :show_posts, :query, :trigger, :auto_revoke, :listable]
end
def self.trust_level_badge_ids
(1..4).to_a
end
def self.like_badge_counts
@like_badge_counts ||= {
NicePost => 10,
GoodPost => 25,
2014-09-10 23:30:47 -04:00
GreatPost => 50,
NiceTopic => 10,
GoodTopic => 25,
GreatTopic => 50
}
end
def reset_grant_count!
self.grant_count = UserBadge.where(badge_id: id).count
save!
end
2014-05-21 03:22:42 -04:00
def single_grant?
!self.multiple_grant?
end
def default_icon=(val)
self.icon ||= val
self.icon = val if self.icon = "fa-certificate"
end
def default_name=(val)
self.name ||= val
end
2014-07-17 02:10:44 -04:00
2014-07-29 18:46:46 -04:00
def default_allow_title=(val)
self.allow_title ||= val
end
2014-07-17 02:10:44 -04:00
def default_badge_grouping_id=(val)
2014-07-18 01:55:42 -04:00
# allow to correct orphans
if !self.badge_grouping_id || self.badge_grouping_id < 0
self.badge_grouping_id = val
end
2014-07-17 02:10:44 -04:00
end
2015-08-14 07:03:49 -04:00
def self.ensure_consistency!
Badge.find_each(&:reset_grant_count!)
end
def display_name
if self.system?
key = "admin_js.badges.badge.#{i18n_name}.name"
I18n.t(key, default: self.name)
else
self.name
end
end
def long_description
if self[:long_description].present?
self[:long_description]
else
key = "badges.long_descriptions.#{i18n_name}"
I18n.t(key, default: '')
end
end
def slug
Slug.for(self.display_name, '-')
end
protected
def ensure_not_system
unless id
self.id = [Badge.maximum(:id) + 1, 100].max
end
end
def i18n_name
self.name.downcase.gsub(' ', '_')
end
2014-03-05 07:52:20 -05:00
end
# == Schema Information
#
# Table name: badges
#
2014-07-17 02:10:44 -04:00
# id :integer not null, primary key
2016-02-22 18:33:53 -05:00
# name :string not null
2014-07-17 02:10:44 -04:00
# description :text
# badge_type_id :integer not null
# grant_count :integer default(0), not null
# created_at :datetime not null
# updated_at :datetime not null
2014-07-17 02:10:44 -04:00
# allow_title :boolean default(FALSE), not null
# multiple_grant :boolean default(FALSE), not null
2016-02-22 18:33:53 -05:00
# icon :string default("fa-certificate")
2014-07-17 02:10:44 -04:00
# listable :boolean default(TRUE)
# target_posts :boolean default(FALSE)
# query :text
# enabled :boolean default(TRUE), not null
# auto_revoke :boolean default(TRUE), not null
2014-07-21 22:46:31 -04:00
# badge_grouping_id :integer default(5), not null
# trigger :integer
# show_posts :boolean default(FALSE), not null
2014-08-06 23:33:11 -04:00
# system :boolean default(FALSE), not null
# image :string(255)
2015-09-17 20:41:10 -04:00
# long_description :text
2014-03-05 07:52:20 -05:00
#
# Indexes
#
2016-02-22 18:33:53 -05:00
# index_badges_on_badge_type_id (badge_type_id)
# index_badges_on_name (name) UNIQUE
2014-03-05 07:52:20 -05:00
#