IntenseWebs/discourse
3
0
Fork 0
mirror of https://github.com/discourse/discourse.git synced 2025-02-25 18:55:32 -06:00
Code Issues Packages Projects Releases Wiki Activity

Add rubocop to our build. (#5004)

Browse Source
This commit is contained in:
Guo Xiang Tan
2017-07-28 10:20:09 +09:00
committed by GitHub
parent ff4e295c4f
commit 5012d46cbd
871 changed files with 5480 additions and 6056 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
app/services/badge_granter.rb
View File

@@ -1,17 +1,17 @@
class BadgeGranter
def initialize(badge, user, opts={})
def initialize(badge, user, opts = {})
@badge, @user, @opts = badge, user, opts
@granted_by = opts[:granted_by] || Discourse.system_user
@post_id = opts[:post_id]
end
def self.grant(badge, user, opts={})
def self.grant(badge, user, opts = {})
BadgeGranter.new(badge, user, opts).grant
end
def grant
return if @granted_by and !Guardian.new(@granted_by).can_grant_badges?(@user)
return if @granted_by && !Guardian.new(@granted_by).can_grant_badges?(@user)
return unless @badge.enabled?
find_by = { badge_id: @badge.id, user_id: @user.id }
@@ -51,7 +51,7 @@ class BadgeGranter
data: { badge_id: @badge.id,
badge_name: @badge.display_name,
badge_slug: @badge.slug,
username: @user.username}.to_json
username: @user.username }.to_json
)
user_badge.update_attributes notification_id: notification.id
end
@@ -63,7 +63,7 @@ class BadgeGranter
user_badge
end
def self.revoke(user_badge, options={})
def self.revoke(user_badge, options = {})
UserBadge.transaction do
user_badge.destroy!
if options[:revoked_by]
@@ -178,7 +178,7 @@ class BadgeGranter
# :trigger - the Badge::Trigger id
# :explain - return the EXPLAIN query
def self.preview(sql, opts = {})
params = {user_ids: [], post_ids: [], backfill: true}
params = { user_ids: [], post_ids: [], backfill: true }
BadgeGranter.contract_checks!(sql, opts)
@@ -188,19 +188,19 @@ class BadgeGranter
grants_sql =
if opts[:target_posts]
"SELECT u.id, u.username, q.post_id, t.title, q.granted_at
FROM(#{sql}) q
JOIN users u on u.id = q.user_id
LEFT JOIN badge_posts p on p.id = q.post_id
LEFT JOIN topics t on t.id = p.topic_id
WHERE :backfill = :backfill
LIMIT 10"
"SELECT u.id, u.username, q.post_id, t.title, q.granted_at
FROM(#{sql}) q
JOIN users u on u.id = q.user_id
LEFT JOIN badge_posts p on p.id = q.post_id
LEFT JOIN topics t on t.id = p.topic_id
WHERE :backfill = :backfill
LIMIT 10"
else
"SELECT u.id, u.username, q.granted_at
FROM(#{sql}) q
JOIN users u on u.id = q.user_id
WHERE :backfill = :backfill
LIMIT 10"
"SELECT u.id, u.username, q.granted_at
FROM(#{sql}) q
JOIN users u on u.id = q.user_id
WHERE :backfill = :backfill
LIMIT 10"
end
query_plan = nil
@@ -218,13 +218,13 @@ class BadgeGranter
end
end
{grant_count: grant_count, sample: sample, query_plan: query_plan}
{ grant_count: grant_count, sample: sample, query_plan: query_plan }
rescue => e
{errors: e.message}
{ errors: e.message }
end
MAX_ITEMS_FOR_DELTA ||= 200
def self.backfill(badge, opts=nil)
def self.backfill(badge, opts = nil)
return unless SiteSetting.enable_badges
return unless badge.enabled
return unless badge.query.present?
@@ -304,14 +304,15 @@ class BadgeGranter
user_ids: user_ids || [-2]).each do |row|
# old bronze badges do not matter
next if badge.badge_type_id == BadgeType::Bronze and row.granted_at < 2.days.ago
next if badge.badge_type_id == (BadgeType::Bronze) && row.granted_at < (2.days.ago)
# Try to use user locale in the badge notification if possible without too much resources
notification_locale = if SiteSetting.allow_user_locale && row.locale.present?
row.locale
else
SiteSetting.default_locale
end
notification_locale =
if SiteSetting.allow_user_locale && row.locale.present?
row.locale
else
SiteSetting.default_locale
end
# Make this variable in this scope
notification = nil
@@ -327,7 +328,7 @@ class BadgeGranter
badge_name: badge.display_name,
badge_slug: badge.slug,
username: row.username
}.to_json )
}.to_json)
end
Badge.exec_sql("UPDATE user_badges SET notification_id = :notification_id WHERE id = :id",

4
app/services/color_scheme_revisor.rb
View File

@@ -1,6 +1,6 @@
class ColorSchemeRevisor
def initialize(color_scheme, params={})
def initialize(color_scheme, params = {})
@color_scheme = color_scheme
@params = params
end
@@ -12,7 +12,7 @@ class ColorSchemeRevisor
def revise
ColorScheme.transaction do
@color_scheme.name = @params[:name] if @params.has_key?(:name)
@color_scheme.name = @params[:name] if @params.has_key?(:name)
@color_scheme.base_scheme_id = @params[:base_scheme_id] if @params.has_key?(:base_scheme_id)
has_colors = @params[:colors]

10
app/services/group_message.rb
View File

@@ -16,11 +16,11 @@ class GroupMessage
include Rails.application.routes.url_helpers
def self.create(group_name, message_type, opts={})
def self.create(group_name, message_type, opts = {})
GroupMessage.new(group_name, message_type, opts).create
end
def initialize(group_name, message_type, opts={})
def initialize(group_name, message_type, opts = {})
@group_name = group_name
@message_type = message_type
@opts = opts
@@ -47,10 +47,8 @@ class GroupMessage
@message_params ||= begin
h = { base_url: Discourse.base_url }.merge(@opts[:message_params] || {})
if @opts[:user]
h.merge!({
username: @opts[:user].username,
user_url: user_path(@opts[:user].username)
})
h.merge!(username: @opts[:user].username,
user_url: user_path(@opts[:user].username))
end
h
end

2
app/services/handle_chunk_upload.rb
View File

@@ -1,6 +1,6 @@
class HandleChunkUpload
def initialize(chunk, params={})
def initialize(chunk, params = {})
@chunk = chunk
@params = params
end

4
app/services/notification_emailer.rb
View File

@@ -66,12 +66,12 @@ class NotificationEmailer
EMAILABLE_POST_TYPES ||= Set.new [Post.types[:regular], Post.types[:whisper]]
def enqueue(type, delay=default_delay)
def enqueue(type, delay = default_delay)
return unless notification.user.user_option.email_direct?
perform_enqueue(type, delay)
end
def enqueue_private(type, delay=private_delay)
def enqueue_private(type, delay = private_delay)
return unless notification.user.user_option.email_private_messages?
perform_enqueue(type, delay)
end

82
app/services/post_alerter.rb
View File

@@ -48,11 +48,11 @@ class PostAlerter
if post.last_editor_id != post.user_id
# Mention comes from an edit by someone else, so notification should say who added the mention.
editor = post.last_editor
mentioned_opts = {user_id: editor.id, original_username: editor.username, display_username: editor.username}
mentioned_opts = { user_id: editor.id, original_username: editor.username, display_username: editor.username }
end
expand_group_mentions(mentioned_groups, post) do |group, users|
notify_non_pm_users(users - notified, :group_mentioned, post, mentioned_opts.merge({group: group}))
notify_non_pm_users(users - notified, :group_mentioned, post, mentioned_opts.merge(group: group))
notified += users
end
@@ -122,17 +122,17 @@ class PostAlerter
if topic.present?
cat_watchers = topic.category_users
.where(notification_level: CategoryUser.notification_levels[:watching_first_post])
.pluck(:user_id)
.where(notification_level: CategoryUser.notification_levels[:watching_first_post])
.pluck(:user_id)
tag_watchers = topic.tag_users
.where(notification_level: TagUser.notification_levels[:watching_first_post])
.pluck(:user_id)
.where(notification_level: TagUser.notification_levels[:watching_first_post])
.pluck(:user_id)
group_ids = topic.allowed_groups.pluck(:group_id)
group_watchers = GroupUser.where(group_id: group_ids,
notification_level: GroupUser.notification_levels[:watching_first_post])
.pluck(:user_id)
.pluck(:user_id)
watchers = [cat_watchers, tag_watchers, group_watchers].flatten
@@ -167,17 +167,17 @@ class PostAlerter
def unread_posts(user, topic)
Post.secured(Guardian.new(user))
.where('post_number > COALESCE((
.where('post_number > COALESCE((
SELECT last_read_post_number FROM topic_users tu
WHERE tu.user_id = ? AND tu.topic_id = ? ),0)',
user.id, topic.id)
.where('reply_to_user_id = ? OR exists(
.where('reply_to_user_id = ? OR exists(
SELECT 1 from topic_users tu
WHERE tu.user_id = ? AND
tu.topic_id = ? AND
notification_level = ?
)', user.id, user.id, topic.id, TopicUser.notification_levels[:watching])
.where(topic_id: topic.id)
.where(topic_id: topic.id)
end
def first_unread_post(user, topic)
@@ -198,7 +198,7 @@ class PostAlerter
user.reload
end
NOTIFIABLE_TYPES = [:mentioned, :replied, :quoted, :posted, :linked, :private_message, :group_mentioned].map{ |t|
NOTIFIABLE_TYPES = [:mentioned, :replied, :quoted, :posted, :linked, :private_message, :group_mentioned].map { |t|
Notification.types[t]
}
@@ -217,18 +217,18 @@ class PostAlerter
end
end
def notify_group_summary(user,post)
def notify_group_summary(user, post)
@group_stats ||= {}
stats = (@group_stats[post.topic_id] ||= group_stats(post.topic))
return unless stats
group_id = post.topic
.topic_allowed_groups
.where(group_id: user.groups.pluck(:id))
.pluck(:group_id).first
.topic_allowed_groups
.where(group_id: user.groups.pluck(:id))
.pluck(:group_id).first
stat = stats.find{|s| s[:group_id] == group_id}
stat = stats.find { |s| s[:group_id] == group_id }
return unless stat && stat[:inbox_count] > 0
notification_type = Notification.types[:group_message_summary]
@@ -297,9 +297,9 @@ class PostAlerter
# apply muting here
return if notifier_id && MutedUser.where(user_id: user.id, muted_user_id: notifier_id)
.joins(:muted_user)
.where('NOT admin AND NOT moderator')
.exists?
.joins(:muted_user)
.where('NOT admin AND NOT moderator')
.exists?
# skip if muted on the topic
return if TopicUser.where(
@@ -319,10 +319,10 @@ class PostAlerter
# Don't notify the same user about the same notification on the same post
existing_notification = user.notifications
.order("notifications.id DESC")
.find_by(topic_id: post.topic_id,
post_number: post.post_number,
notification_type: type)
.order("notifications.id DESC")
.find_by(topic_id: post.topic_id,
post_number: post.post_number,
notification_type: type)
return if existing_notification && !should_notify_previous?(user, existing_notification, opts)
@@ -376,13 +376,11 @@ class PostAlerter
end
end
notification_data.merge!({
topic_title: topic_title,
original_post_id: original_post.id,
original_post_type: original_post.post_type,
original_username: original_username,
display_username: opts[:display_username] || post.user.username
})
notification_data.merge!(topic_title: topic_title,
original_post_id: original_post.id,
original_post_type: original_post.post_type,
original_username: original_username,
display_username: opts[:display_username] || post.user.username)
if group = opts[:group]
notification_data[:group_id] = group.id
@@ -401,15 +399,15 @@ class PostAlerter
# we may have an invalid post somehow, dont blow up
post_url = original_post.url rescue nil
if post_url
payload = {
notification_type: type,
post_number: original_post.post_number,
topic_title: original_post.topic.title,
topic_id: original_post.topic.id,
excerpt: original_post.excerpt(400, text_entities: true, strip_links: true, remap_emoji: true),
username: original_username,
post_url: post_url
}
payload = {
notification_type: type,
post_number: original_post.post_number,
topic_title: original_post.topic.title,
topic_id: original_post.topic.id,
excerpt: original_post.excerpt(400, text_entities: true, strip_links: true, remap_emoji: true),
username: original_username,
post_url: post_url
}
MessageBus.publish("/notification-alert/#{user.id}", payload, user_ids: [user.id])
push_notification(user, payload)
@@ -422,9 +420,9 @@ class PostAlerter
def push_notification(user, payload)
if SiteSetting.allow_user_api_key_scopes.split("|").include?("push") && SiteSetting.allowed_user_api_push_urls.present?
clients = user.user_api_keys
.where("('push' = ANY(scopes) OR 'notifications' = ANY(scopes)) AND push_url IS NOT NULL AND position(push_url in ?) > 0 AND revoked_at IS NULL",
.where("('push' = ANY(scopes) OR 'notifications' = ANY(scopes)) AND push_url IS NOT NULL AND position(push_url in ?) > 0 AND revoked_at IS NULL",
SiteSetting.allowed_user_api_push_urls)
.pluck(:client_id, :push_url)
.pluck(:client_id, :push_url)
if clients.length > 0
Jobs.enqueue(:push_notification, clients: clients, payload: payload, user_id: user.id)
@@ -458,7 +456,6 @@ class PostAlerter
[groups, users]
end
# TODO: Move to post-analyzer?
# Returns a list of users who were quoted in the post
def extract_quoted_users(post)
@@ -530,7 +527,6 @@ SQL
exclude_user_ids = notified.map(&:id)
notify = notify.where("id NOT IN (?)", exclude_user_ids) if exclude_user_ids.present?
DiscourseEvent.trigger(:before_create_notifications_for_users, notify, post)
notify.each do |user|
create_notification(user, Notification.types[:posted], post)

21
app/services/random_topic_selector.rb
View File

@@ -3,7 +3,7 @@ class RandomTopicSelector
BACKFILL_SIZE = 3000
BACKFILL_LOW_WATER_MARK = 500
def self.backfill(category=nil)
def self.backfill(category = nil)
exclude = category.try(:topic_id)
# don't leak private categories into the "everything" group
@@ -20,13 +20,12 @@ class RandomTopicSelector
query = TopicQuery.new(user, options)
results = query.latest_results.order('RANDOM()')
.where(closed: false, archived: false)
.where("topics.created_at > ?", SiteSetting.suggested_topics_max_days_old.days.ago)
.limit(BACKFILL_SIZE)
.reorder('RANDOM()')
.pluck(:id)
.where(closed: false, archived: false)
.where("topics.created_at > ?", SiteSetting.suggested_topics_max_days_old.days.ago)
.limit(BACKFILL_SIZE)
.reorder('RANDOM()')
.pluck(:id)
key = cache_key(category)
results.each do |id|
@@ -37,7 +36,7 @@ class RandomTopicSelector
results
end
def self.next(count, category=nil)
def self.next(count, category = nil)
key = cache_key(category)
results = []
@@ -45,12 +44,12 @@ class RandomTopicSelector
return results if count < 1
results = $redis.multi do
$redis.lrange(key, 0, count-1)
$redis.lrange(key, 0, count - 1)
$redis.ltrim(key, count, -1)
end
if !results.is_a?(Array) # Redis is in readonly mode
results = $redis.lrange(key, 0, count-1)
results = $redis.lrange(key, 0, count - 1)
else
results = results[0]
end
@@ -77,7 +76,7 @@ class RandomTopicSelector
results
end
def self.cache_key(category=nil)
def self.cache_key(category = nil)
"random_topic_cache_#{category.try(:id)}"
end

3
app/services/search_indexer.rb
View File

@@ -110,7 +110,6 @@ class SearchIndexer
end
end
class HtmlScrubber < Nokogiri::XML::SAX::Document
attr_reader :scrubbed
@@ -130,7 +129,7 @@ class SearchIndexer
me.scrubbed
end
def start_element(name, attributes=[])
def start_element(name, attributes = [])
attributes = Hash[*attributes.flatten]
if attributes["alt"]
scrubbed << " "

22
app/services/spam_rule/auto_block.rb
View File

@@ -21,17 +21,17 @@ class SpamRule::AutoBlock
return false if @user.staged?
return false if @user.has_trust_level?(TrustLevel[1])
if SiteSetting.num_spam_flags_to_block_new_user > 0 and
SiteSetting.num_users_to_block_new_user > 0 and
num_spam_flags_against_user >= SiteSetting.num_spam_flags_to_block_new_user and
num_users_who_flagged_spam_against_user >= SiteSetting.num_users_to_block_new_user
if SiteSetting.num_spam_flags_to_block_new_user > (0) &&
SiteSetting.num_users_to_block_new_user > (0) &&
num_spam_flags_against_user >= (SiteSetting.num_spam_flags_to_block_new_user) &&
num_users_who_flagged_spam_against_user >= (SiteSetting.num_users_to_block_new_user)
return true
end
if SiteSetting.num_tl3_flags_to_block_new_user > 0 and
SiteSetting.num_tl3_users_to_block_new_user > 0 and
num_tl3_flags_against_user >= SiteSetting.num_tl3_flags_to_block_new_user and
num_tl3_users_who_flagged >= SiteSetting.num_tl3_users_to_block_new_user
if SiteSetting.num_tl3_flags_to_block_new_user > (0) &&
SiteSetting.num_tl3_users_to_block_new_user > (0) &&
num_tl3_flags_against_user >= (SiteSetting.num_tl3_flags_to_block_new_user) &&
num_tl3_users_who_flagged >= (SiteSetting.num_tl3_users_to_block_new_user)
return true
end
@@ -66,14 +66,14 @@ class SpamRule::AutoBlock
def flagged_post_ids
Post.where(user_id: @user.id)
.where('spam_count > ? OR off_topic_count > ? OR inappropriate_count > ?', 0, 0, 0)
.pluck(:id)
.where('spam_count > ? OR off_topic_count > ? OR inappropriate_count > ?', 0, 0, 0)
.pluck(:id)
end
def block_user
Post.transaction do
if UserBlocker.block(@user, Discourse.system_user, message: :too_many_spam_flags) && SiteSetting.notify_mods_when_user_blocked
GroupMessage.create(Group[:moderators].name, :user_automatically_blocked, {user: @user, limit_once_per: false})
GroupMessage.create(Group[:moderators].name, :user_automatically_blocked, user: @user, limit_once_per: false)
end
end
end

362
app/services/staff_action_logger.rb
View File

@@ -10,16 +10,14 @@ class StaffActionLogger
raise Discourse::InvalidParameters.new(:admin) unless @admin && @admin.is_a?(User)
end
def log_user_deletion(deleted_user, opts={})
def log_user_deletion(deleted_user, opts = {})
raise Discourse::InvalidParameters.new(:deleted_user) unless deleted_user && deleted_user.is_a?(User)
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:delete_user],
ip_address: deleted_user.ip_address.to_s,
details: [:id, :username, :name, :created_at, :trust_level, :last_seen_at, :last_emailed_at].map { |x| "#{x}: #{deleted_user.send(x)}" }.join("\n")
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:delete_user],
ip_address: deleted_user.ip_address.to_s,
details: [:id, :username, :name, :created_at, :trust_level, :last_seen_at, :last_emailed_at].map { |x| "#{x}: #{deleted_user.send(x)}" }.join("\n")))
end
def log_custom(custom_type, details=nil)
def log_custom(custom_type, details = nil)
raise Discourse::InvalidParameters.new(:custom_type) unless custom_type
details ||= {}
@@ -28,7 +26,7 @@ class StaffActionLogger
StaffActionLogger.base_attrs.each do |attr|
attrs[attr] = details.delete(attr) if details.has_key?(attr)
end
attrs[:details] = details.map {|r| "#{r[0]}: #{r[1]}"}.join("\n")
attrs[:details] = details.map { |r| "#{r[0]}: #{r[1]}" }.join("\n")
attrs[:acting_user_id] = @admin.id
attrs[:action] = UserHistory.actions[:custom_staff]
attrs[:custom_type] = custom_type
@@ -36,7 +34,7 @@ class StaffActionLogger
UserHistory.create(attrs)
end
def log_post_deletion(deleted_post, opts={})
def log_post_deletion(deleted_post, opts = {})
raise Discourse::InvalidParameters.new(:deleted_post) unless deleted_post && deleted_post.is_a?(Post)
topic = deleted_post.topic || Topic.with_deleted.find_by(id: deleted_post.topic_id)
@@ -54,14 +52,12 @@ class StaffActionLogger
"raw: #{deleted_post.raw}"
]
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:delete_post],
post_id: deleted_post.id,
details: details.join("\n")
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:delete_post],
post_id: deleted_post.id,
details: details.join("\n")))
end
def log_topic_deletion(deleted_topic, opts={})
def log_topic_deletion(deleted_topic, opts = {})
raise Discourse::InvalidParameters.new(:deleted_topic) unless deleted_topic && deleted_topic.is_a?(Topic)
user = deleted_topic.user ? "#{deleted_topic.user.username} (#{deleted_topic.user.name})" : "(deleted user)"
@@ -77,48 +73,40 @@ class StaffActionLogger
details << "raw: #{first_post.raw}"
end
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:delete_topic],
topic_id: deleted_topic.id,
details: details.join("\n")
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:delete_topic],
topic_id: deleted_topic.id,
details: details.join("\n")))
end
def log_trust_level_change(user, old_trust_level, new_trust_level, opts={})
def log_trust_level_change(user, old_trust_level, new_trust_level, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user && user.is_a?(User)
raise Discourse::InvalidParameters.new(:old_trust_level) unless TrustLevel.valid? old_trust_level
raise Discourse::InvalidParameters.new(:new_trust_level) unless TrustLevel.valid? new_trust_level
UserHistory.create!( params(opts).merge({
action: UserHistory.actions[:change_trust_level],
target_user_id: user.id,
details: "old trust level: #{old_trust_level}\nnew trust level: #{new_trust_level}"
}))
UserHistory.create!(params(opts).merge(action: UserHistory.actions[:change_trust_level],
target_user_id: user.id,
details: "old trust level: #{old_trust_level}\nnew trust level: #{new_trust_level}"))
end
def log_lock_trust_level(user, opts={})
def log_lock_trust_level(user, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user && user.is_a?(User)
UserHistory.create!( params(opts).merge({
action: UserHistory.actions[user.trust_level_locked ? :lock_trust_level : :unlock_trust_level],
target_user_id: user.id
}))
UserHistory.create!(params(opts).merge(action: UserHistory.actions[user.trust_level_locked ? :lock_trust_level : :unlock_trust_level],
target_user_id: user.id))
end
def log_site_setting_change(setting_name, previous_value, new_value, opts={})
def log_site_setting_change(setting_name, previous_value, new_value, opts = {})
raise Discourse::InvalidParameters.new(:setting_name) unless setting_name.present? && SiteSetting.respond_to?(setting_name)
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:change_site_setting],
subject: setting_name,
previous_value: previous_value,
new_value: new_value
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:change_site_setting],
subject: setting_name,
previous_value: previous_value,
new_value: new_value))
end
def theme_json(theme)
ThemeSerializer.new(theme, root:false).to_json
ThemeSerializer.new(theme, root: false).to_json
end
def strip_duplicates(old,cur)
return [old,cur] unless old && cur
def strip_duplicates(old, cur)
return [old, cur] unless old && cur
old = JSON.parse(old)
cur = JSON.parse(cur)
@@ -135,144 +123,116 @@ class StaffActionLogger
[old.to_json, cur.to_json]
end
def log_theme_change(old_json, new_theme, opts={})
def log_theme_change(old_json, new_theme, opts = {})
raise Discourse::InvalidParameters.new(:new_theme) unless new_theme
new_json = theme_json(new_theme)
old_json,new_json = strip_duplicates(old_json,new_json)
old_json, new_json = strip_duplicates(old_json, new_json)
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:change_theme],
subject: new_theme.name,
previous_value: old_json,
new_value: new_json
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:change_theme],
subject: new_theme.name,
previous_value: old_json,
new_value: new_json))
end
def log_theme_destroy(theme, opts={})
def log_theme_destroy(theme, opts = {})
raise Discourse::InvalidParameters.new(:theme) unless theme
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:delete_theme],
subject: theme.name,
previous_value: theme_json(theme)
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:delete_theme],
subject: theme.name,
previous_value: theme_json(theme)))
end
def log_site_text_change(subject, new_text=nil, old_text=nil, opts={})
def log_site_text_change(subject, new_text = nil, old_text = nil, opts = {})
raise Discourse::InvalidParameters.new(:subject) unless subject.present?
UserHistory.create!( params(opts).merge({
action: UserHistory.actions[:change_site_text],
subject: subject,
previous_value: old_text,
new_value: new_text
}))
UserHistory.create!(params(opts).merge(action: UserHistory.actions[:change_site_text],
subject: subject,
previous_value: old_text,
new_value: new_text))
end
def log_username_change(user, old_username, new_username, opts={})
def log_username_change(user, old_username, new_username, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:change_username],
target_user_id: user.id,
previous_value: old_username,
new_value: new_username
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:change_username],
target_user_id: user.id,
previous_value: old_username,
new_value: new_username))
end
def log_name_change(user_id, old_name, new_name, opts={})
def log_name_change(user_id, old_name, new_name, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user_id
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:change_name],
target_user_id: user_id,
previous_value: old_name,
new_value: new_name
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:change_name],
target_user_id: user_id,
previous_value: old_name,
new_value: new_name))
end
def log_user_suspend(user, reason, opts={})
def log_user_suspend(user, reason, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:suspend_user],
target_user_id: user.id,
details: reason
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:suspend_user],
target_user_id: user.id,
details: reason))
end
def log_user_unsuspend(user, opts={})
def log_user_unsuspend(user, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:unsuspend_user],
target_user_id: user.id
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:unsuspend_user],
target_user_id: user.id))
end
def log_badge_grant(user_badge, opts={})
def log_badge_grant(user_badge, opts = {})
raise Discourse::InvalidParameters.new(:user_badge) unless user_badge
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:grant_badge],
target_user_id: user_badge.user_id,
details: user_badge.badge.name
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:grant_badge],
target_user_id: user_badge.user_id,
details: user_badge.badge.name))
end
def log_badge_revoke(user_badge, opts={})
def log_badge_revoke(user_badge, opts = {})
raise Discourse::InvalidParameters.new(:user_badge) unless user_badge
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:revoke_badge],
target_user_id: user_badge.user_id,
details: user_badge.badge.name
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:revoke_badge],
target_user_id: user_badge.user_id,
details: user_badge.badge.name))
end
def log_check_email(user, opts={})
def log_check_email(user, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:check_email],
target_user_id: user.id
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:check_email],
target_user_id: user.id))
end
def log_show_emails(users, opts={})
def log_show_emails(users, opts = {})
return if users.blank?
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:check_email],
details: users.map { |u| "[#{u.id}] #{u.username}"}.join("\n")
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:check_email],
details: users.map { |u| "[#{u.id}] #{u.username}" }.join("\n")))
end
def log_impersonate(user, opts={})
def log_impersonate(user, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:impersonate],
target_user_id: user.id
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:impersonate],
target_user_id: user.id))
end
def log_roll_up(subnets, opts={})
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:roll_up],
details: subnets.join(", ")
}))
def log_roll_up(subnets, opts = {})
UserHistory.create(params(opts).merge(action: UserHistory.actions[:roll_up],
details: subnets.join(", ")))
end
def log_category_settings_change(category, category_params, old_permissions=nil)
def log_category_settings_change(category, category_params, old_permissions = nil)
validate_category(category)
changed_attributes = category.previous_changes.slice(*category_params.keys)
if !old_permissions.empty? && (old_permissions != category_params[:permissions])
changed_attributes.merge!({ permissions: [old_permissions.to_json, category_params[:permissions].to_json] })
changed_attributes.merge!(permissions: [old_permissions.to_json, category_params[:permissions].to_json])
end
changed_attributes.each do |key, value|
UserHistory.create(params.merge({
action: UserHistory.actions[:change_category_settings],
category_id: category.id,
context: category.url,
subject: key,
previous_value: value[0],
new_value: value[1]
}))
UserHistory.create(params.merge(action: UserHistory.actions[:change_category_settings],
category_id: category.id,
context: category.url,
subject: key,
previous_value: value[0],
new_value: value[1]))
end
end
@@ -289,12 +249,10 @@ class StaffActionLogger
details << "parent_category: #{parent_category.name}"
end
UserHistory.create(params.merge({
action: UserHistory.actions[:delete_category],
category_id: category.id,
details: details.join("\n"),
context: category.url
}))
UserHistory.create(params.merge(action: UserHistory.actions[:delete_category],
category_id: category.id,
details: details.join("\n"),
context: category.url))
end
def log_category_creation(category)
@@ -305,132 +263,102 @@ class StaffActionLogger
"name: #{category.name}"
]
UserHistory.create(params.merge({
action: UserHistory.actions[:create_category],
details: details.join("\n"),
category_id: category.id,
context: category.url
}))
UserHistory.create(params.merge(action: UserHistory.actions[:create_category],
details: details.join("\n"),
category_id: category.id,
context: category.url))
end
def log_block_user(user, opts={})
def log_block_user(user, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:block_user],
target_user_id: user.id
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:block_user],
target_user_id: user.id))
end
def log_unblock_user(user, opts={})
def log_unblock_user(user, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:unblock_user],
target_user_id: user.id
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:unblock_user],
target_user_id: user.id))
end
def log_grant_admin(user, opts={})
def log_grant_admin(user, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:grant_admin],
target_user_id: user.id
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:grant_admin],
target_user_id: user.id))
end
def log_revoke_admin(user, opts={})
def log_revoke_admin(user, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:revoke_admin],
target_user_id: user.id
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:revoke_admin],
target_user_id: user.id))
end
def log_grant_moderation(user, opts={})
def log_grant_moderation(user, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:grant_moderation],
target_user_id: user.id
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:grant_moderation],
target_user_id: user.id))
end
def log_revoke_moderation(user, opts={})
def log_revoke_moderation(user, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create( params(opts).merge({
action: UserHistory.actions[:revoke_moderation],
target_user_id: user.id
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:revoke_moderation],
target_user_id: user.id))
end
def log_backup_create(opts={})
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:backup_create],
ip_address: @admin.ip_address.to_s
}))
def log_backup_create(opts = {})
UserHistory.create(params(opts).merge(action: UserHistory.actions[:backup_create],
ip_address: @admin.ip_address.to_s))
end
def log_backup_download(backup, opts={})
def log_backup_download(backup, opts = {})
raise Discourse::InvalidParameters.new(:backup) unless backup
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:backup_download],
ip_address: @admin.ip_address.to_s,
details: backup.filename
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:backup_download],
ip_address: @admin.ip_address.to_s,
details: backup.filename))
end
def log_backup_destroy(backup, opts={})
def log_backup_destroy(backup, opts = {})
raise Discourse::InvalidParameters.new(:backup) unless backup
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:backup_destroy],
ip_address: @admin.ip_address.to_s,
details: backup.filename
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:backup_destroy],
ip_address: @admin.ip_address.to_s,
details: backup.filename))
end
def log_revoke_email(user, reason, opts={})
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:revoke_email],
target_user_id: user.id,
details: reason
}))
def log_revoke_email(user, reason, opts = {})
UserHistory.create(params(opts).merge(action: UserHistory.actions[:revoke_email],
target_user_id: user.id,
details: reason))
end
def log_user_deactivate(user, reason, opts={})
def log_user_deactivate(user, reason, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:deactivate_user],
target_user_id: user.id,
details: reason
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:deactivate_user],
target_user_id: user.id,
details: reason))
end
def log_user_activate(user, reason, opts={})
def log_user_activate(user, reason, opts = {})
raise Discourse::InvalidParameters.new(:user) unless user
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:activate_user],
target_user_id: user.id,
details: reason
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:activate_user],
target_user_id: user.id,
details: reason))
end
def log_wizard_step(step, opts={})
def log_wizard_step(step, opts = {})
raise Discourse::InvalidParameters.new(:step) unless step
UserHistory.create(params(opts).merge({
action: UserHistory.actions[:wizard_step],
context: step.id
}))
UserHistory.create(params(opts).merge(action: UserHistory.actions[:wizard_step],
context: step.id))
end
def log_change_readonly_mode(state)
UserHistory.create(params.merge({
action: UserHistory.actions[:change_readonly_mode],
previous_value: !state,
new_value: state
}))
UserHistory.create(params.merge(action: UserHistory.actions[:change_readonly_mode],
previous_value: !state,
new_value: state))
end
private
def params(opts=nil)
def params(opts = nil)
opts ||= {}
{ acting_user_id: @admin.id, context: opts[:context] }
end

8
app/services/topic_status_updater.rb
View File

@@ -1,5 +1,5 @@
TopicStatusUpdater = Struct.new(:topic, :user) do
def update!(status, enabled, opts={})
def update!(status, enabled, opts = {})
status = Status.new(status, enabled)
@topic_status_update = topic.public_topic_timer
@@ -19,7 +19,7 @@ TopicStatusUpdater = Struct.new(:topic, :user) do
private
def change(status, opts={})
def change(status, opts = {})
result = true
if status.pinned? || status.pinned_globally?
@@ -30,7 +30,7 @@ TopicStatusUpdater = Struct.new(:topic, :user) do
result = false if rc == 0
else
rc = Topic.where(:id => topic.id, status.name => !status.enabled)
.update_all(status.name => status.enabled?)
.update_all(status.name => status.enabled?)
topic.send("#{status.name}=", status.enabled?)
result = false if rc == 0
@@ -55,7 +55,7 @@ TopicStatusUpdater = Struct.new(:topic, :user) do
result
end
def create_moderator_post_for(status, message=nil)
def create_moderator_post_for(status, message = nil)
topic.add_moderator_post(user, message || message_for(status), options_for(status))
topic.reload
end

3
app/services/tracked_topics_updater.rb
View File

@@ -8,11 +8,10 @@ class TrackedTopicsUpdater
def call
topic_users = TopicUser.where(notifications_reason_id: nil, user_id: @id)
if @threshold < 0
topic_users.update_all({notification_level: TopicUser.notification_levels[:regular]})
topic_users.update_all(notification_level: TopicUser.notification_levels[:regular])
else
topic_users.update_all(["notification_level = CASE WHEN total_msecs_viewed < ? THEN ? ELSE ? END",
@threshold, TopicUser.notification_levels[:regular], TopicUser.notification_levels[:tracking]])
end
end
end

18
app/services/user_action_creator.rb
View File

@@ -7,19 +7,19 @@ class UserActionCreator
@disabled = false
end
def self.log_notification(post, user, notification_type, acting_user_id=nil)
def self.log_notification(post, user, notification_type, acting_user_id = nil)
return if @disabled
action =
case notification_type
when Notification.types[:quoted]
UserAction::QUOTE
when Notification.types[:replied]
UserAction::RESPONSE
when Notification.types[:mentioned]
UserAction::MENTION
when Notification.types[:edited]
UserAction::EDIT
when Notification.types[:quoted]
UserAction::QUOTE
when Notification.types[:replied]
UserAction::RESPONSE
when Notification.types[:mentioned]
UserAction::MENTION
when Notification.types[:edited]
UserAction::EDIT
end
# skip any invalid items, eg failed to save post and so on

14
app/services/user_anonymizer.rb
View File

@@ -1,10 +1,10 @@
class UserAnonymizer
def initialize(user, actor=nil)
def initialize(user, actor = nil)
@user = user
@actor = actor
end
def self.make_anonymous(user, actor=nil)
def self.make_anonymous(user, actor = nil)
self.new(user, actor).make_anonymous
end
@@ -48,11 +48,11 @@ class UserAnonymizer
@user.user_open_ids.find_each { |x| x.destroy }
@user.api_key.try(:destroy)
UserHistory.create( action: UserHistory.actions[:anonymize_user],
target_user_id: @user.id,
acting_user_id: @actor ? @actor.id : @user.id,
email: prev_email,
details: "username: #{prev_username}" )
UserHistory.create(action: UserHistory.actions[:anonymize_user],
target_user_id: @user.id,
acting_user_id: @actor ? @actor.id : @user.id,
email: prev_email,
details: "username: #{prev_username}")
end
@user
end

8
app/services/user_blocker.rb
View File

@@ -1,14 +1,14 @@
class UserBlocker
def initialize(user, by_user=nil, opts={})
def initialize(user, by_user = nil, opts = {})
@user, @by_user, @opts = user, by_user, opts
end
def self.block(user, by_user=nil, opts={})
def self.block(user, by_user = nil, opts = {})
UserBlocker.new(user, by_user, opts).block
end
def self.unblock(user, by_user=nil, opts={})
def self.unblock(user, by_user = nil, opts = {})
UserBlocker.new(user, by_user, opts).unblock
end
@@ -20,7 +20,7 @@ class UserBlocker
message_type = @opts[:message] || :blocked_by_staff
post = SystemMessage.create(@user, message_type)
if post && @by_user
StaffActionLogger.new(@by_user).log_block_user(@user, {context: "#{message_type}: '#{post.topic&.title rescue ''}' #{@opts[:reason]}"})
StaffActionLogger.new(@by_user).log_block_user(@user, context: "#{message_type}: '#{post.topic&.title rescue ''}' #{@opts[:reason]}")
end
end
else

6
app/services/user_destroyer.rb
View File

@@ -7,14 +7,14 @@ class UserDestroyer
def initialize(actor)
@actor = actor
raise Discourse::InvalidParameters.new('acting user is nil') unless @actor and @actor.is_a?(User)
raise Discourse::InvalidParameters.new('acting user is nil') unless @actor && @actor.is_a?(User)
@guardian = Guardian.new(actor)
end
# Returns false if the user failed to be deleted.
# Returns a frozen instance of the User if the delete succeeded.
def destroy(user, opts={})
raise Discourse::InvalidParameters.new('user is nil') unless user and user.is_a?(User)
def destroy(user, opts = {})
raise Discourse::InvalidParameters.new('user is nil') unless user && user.is_a?(User)
raise PostsExistError if !opts[:delete_posts] && user.posts.count != 0
@guardian.ensure_can_delete_user!(user)

4
app/services/username_changer.rb
View File

@@ -1,12 +1,12 @@
class UsernameChanger
def initialize(user, new_username, actor=nil)
def initialize(user, new_username, actor = nil)
@user = user
@new_username = new_username
@actor = actor
end
def self.change(user, new_username, actor=nil)
def self.change(user, new_username, actor = nil)
self.new(user, new_username, actor).change
end

3
app/services/username_checker_service.rb
View File

@@ -4,7 +4,7 @@ class UsernameCheckerService
if username && username.length > 0
validator = UsernameValidator.new(username)
if !validator.valid_format?
{errors: validator.errors}
{ errors: validator.errors }
else
check_username_availability(username, email)
end
@@ -23,7 +23,6 @@ class UsernameCheckerService
Rails.configuration.respond_to?(:developer_emails) && Rails.configuration.developer_emails.include?(value)
end
def self.is_developer?(email)
UsernameCheckerService.new.is_developer?(email)
end

2
app/services/word_watcher.rb
View File

@@ -26,7 +26,7 @@ class WordWatcher
end
def self.clear_cache!
WatchedWord.actions.sum do |a,i|
WatchedWord.actions.sum do |a, i|
Discourse.cache.delete word_matcher_regexp_key(a)
end
end