discourse/app/services/post_alerter.rb

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1013 lines
33 KiB
Ruby
Raw Normal View History

# frozen_string_literal: true
class PostAlerter
USER_BATCH_SIZE = 100
def self.post_created(post, opts = {})
2018-05-15 03:51:32 -04:00
PostAlerter.new(opts).after_save_post(post, true)
post
end
def self.post_edited(post, opts = {})
PostAlerter.new(opts).after_save_post(post, false)
post
end
def self.create_notification_alert(user:, post:, notification_type:, excerpt: nil, username: nil)
return if user.suspended?
if post_url = post.url
payload = {
notification_type: notification_type,
post_number: post.post_number,
topic_title: post.topic.title,
topic_id: post.topic.id,
excerpt:
excerpt ||
post.excerpt(
400,
text_entities: true,
strip_links: true,
remap_emoji: true,
plain_hashtags: true,
),
username: username || post.username,
post_url: post_url,
}
DiscourseEvent.trigger(:pre_notification_alert, user, payload)
if user.allow_live_notifications?
MessageBus.publish("/notification-alert/#{user.id}", payload, user_ids: [user.id])
end
push_notification(user, payload)
DiscourseEvent.trigger(:post_notification_alert, user, payload)
end
end
def self.push_notification(user, payload)
return if user.do_not_disturb?
DiscoursePluginRegistry.push_notification_filters.each do |filter|
return unless filter.call(user, payload)
end
if user.push_subscriptions.exists?
if user.seen_since?(SiteSetting.push_notification_time_window_mins.minutes.ago)
delay =
(SiteSetting.push_notification_time_window_mins - (Time.now - user.last_seen_at) / 60)
Jobs.enqueue_in(delay.minutes, :send_push_notification, user_id: user.id, payload: payload)
else
Jobs.enqueue(:send_push_notification, user_id: user.id, payload: payload)
end
end
if SiteSetting.allow_user_api_key_scopes.split("|").include?("push") &&
SiteSetting.allowed_user_api_push_urls.present?
clients =
user
.user_api_keys
.joins(:scopes)
.where("user_api_key_scopes.name IN ('push', 'notifications')")
.where("push_url IS NOT NULL AND push_url <> ''")
.where("position(push_url IN ?) > 0", SiteSetting.allowed_user_api_push_urls)
.where("revoked_at IS NULL")
.order(client_id: :asc)
.pluck(:client_id, :push_url)
if clients.length > 0
Jobs.enqueue(:push_notification, clients: clients, payload: payload, user_id: user.id)
end
end
end
def initialize(default_opts = {})
@default_opts = default_opts
end
def not_allowed?(user, post)
user.blank? || user.bot? || user.id == post.user_id
end
def all_allowed_users(post)
@all_allowed_users ||= post.topic.all_allowed_users.reject { |u| not_allowed?(u, post) }
end
2015-05-25 13:15:00 -04:00
def allowed_users(post)
@allowed_users ||= post.topic.allowed_users.reject { |u| not_allowed?(u, post) }
2015-05-25 13:15:00 -04:00
end
def allowed_group_users(post)
@allowed_group_users ||= post.topic.allowed_group_users.reject { |u| not_allowed?(u, post) }
end
def directly_targeted_users(post)
allowed_users(post) - allowed_group_users(post)
end
def indirectly_targeted_users(post)
allowed_group_users(post)
end
def only_allowed_users(users, post)
return users unless post.topic.private_message?
users.select { |u| all_allowed_users(post).include?(u) }
end
2017-09-19 09:51:10 -04:00
def notify_about_reply?(post)
# small actions can be whispers in this case they will have an action code
# we never want to notify on this
post.post_type == Post.types[:regular] ||
(post.post_type == Post.types[:whisper] && post.action_code.nil?)
2017-09-19 09:51:10 -04:00
end
def after_save_post(post, new_record = false)
notified = [post.user, post.last_editor].uniq
DiscourseEvent.trigger(:post_alerter_before_mentions, post, new_record, notified)
# mentions (users/groups)
mentioned_groups, mentioned_users, mentioned_here = extract_mentions(post)
if mentioned_groups || mentioned_users || mentioned_here
mentioned_opts = {}
editor = post.last_editor
if post.last_editor_id != post.user_id
# Mention comes from an edit by someone else, so notification should say who added the mention.
mentioned_opts = {
user_id: editor.id,
original_username: editor.username,
display_username: editor.username,
}
end
if mentioned_users
mentioned_users = only_allowed_users(mentioned_users, post)
mentioned_users = mentioned_users - pm_watching_users(post)
notified += notify_users(mentioned_users - notified, :mentioned, post, mentioned_opts)
end
expand_group_mentions(mentioned_groups, post) do |group, users|
users = only_allowed_users(users, post)
notified +=
notify_users(users - notified, :group_mentioned, post, mentioned_opts.merge(group: group))
end
if mentioned_here
users = expand_here_mention(post, exclude_ids: notified.map(&:id))
users = only_allowed_users(users, post)
notified += notify_users(users - notified, :mentioned, post, mentioned_opts)
end
end
DiscourseEvent.trigger(:post_alerter_before_replies, post, new_record, notified)
# replies
reply_to_user = post.reply_notification_target
if new_record && notify_about_reply?(post)
if reply_to_user && !notified.include?(reply_to_user)
notified += notify_non_pm_users(reply_to_user, :replied, post)
end
topic_author = post.topic.user
if topic_author && !notified.include?(topic_author) &&
user_watching_topic?(topic_author, post.topic)
notified += notify_non_pm_users(topic_author, :replied, post)
end
end
DiscourseEvent.trigger(:post_alerter_before_quotes, post, new_record, notified)
# quotes
quoted_users = extract_quoted_users(post)
notified += notify_non_pm_users(quoted_users - notified, :quoted, post)
DiscourseEvent.trigger(:post_alerter_before_linked, post, new_record, notified)
# linked
linked_users = extract_linked_users(post)
notified += notify_non_pm_users(linked_users - notified, :linked, post)
DiscourseEvent.trigger(:post_alerter_before_post, post, new_record, notified)
if new_record
if post.topic.private_message?
# private messages
notified += notify_pm_users(post, reply_to_user, quoted_users, notified)
elsif notify_about_reply?(post)
# posts
notified +=
notify_post_users(
post,
notified,
new_record: new_record,
include_category_watchers: false,
include_tag_watchers: false,
)
notified +=
notify_post_users(
post,
notified,
new_record: new_record,
include_topic_watchers: false,
notification_type: :watching_category_or_tag,
)
end
end
sync_group_mentions(post, mentioned_groups)
DiscourseEvent.trigger(:post_alerter_before_first_post, post, new_record, notified)
if new_record && post.post_number == 1
topic = post.topic
if topic.present?
watchers = category_watchers(topic) + tag_watchers(topic) + group_watchers(topic)
# Notify only users who can see the topic
watchers &= topic.all_allowed_users.pluck(:id) if post.topic.private_message?
notified += notify_first_post_watchers(post, watchers, notified)
end
end
DiscourseEvent.trigger(:post_alerter_after_save_post, post, new_record, notified)
end
def group_watchers(topic)
GroupUser.where(
group_id: topic.allowed_groups.pluck(:group_id),
notification_level: GroupUser.notification_levels[:watching_first_post],
).pluck(:user_id)
end
def tag_watchers(topic)
topic
.tag_users
.notification_level_visible([TagUser.notification_levels[:watching_first_post]])
.distinct(:user_id)
.pluck(:user_id)
end
def category_watchers(topic)
topic
.category_users
.where(notification_level: CategoryUser.notification_levels[:watching_first_post])
.pluck(:user_id)
end
def notify_first_post_watchers(post, user_ids, notified = nil)
return [] if user_ids.blank?
user_ids.uniq!
warn_if_not_sidekiq
# Don't notify the OP and last editor
user_ids -= [post.user_id, post.last_editor_id]
users = User.where(id: user_ids).includes(:do_not_disturb_timings)
users = users.where.not(id: notified.map(&:id)) if notified.present?
2018-05-07 05:44:29 -04:00
DiscourseEvent.trigger(:before_create_notifications_for_users, users, post)
each_user_in_batches(users) do |user|
create_notification(user, Notification.types[:watching_first_post], post)
end
users
end
def sync_group_mentions(post, mentioned_groups)
GroupMention.where(post_id: post.id).destroy_all
return if mentioned_groups.blank?
now = Time.zone.now
# insert_all instead of insert_all! since multiple post_alert jobs might be
# running concurrently
GroupMention.insert_all(
mentioned_groups.map do |group|
{ post_id: post.id, group_id: group.id, created_at: now, updated_at: now }
end,
)
end
def unread_posts(user, topic)
Post
.secured(Guardian.new(user))
.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 = :user_id
OR exists(SELECT 1 from topic_users tu
WHERE tu.user_id = :user_id AND
tu.topic_id = :topic_id AND
notification_level = :topic_level)
OR exists(SELECT 1 from category_users cu
WHERE cu.user_id = :user_id AND
cu.category_id = :category_id AND
notification_level = :category_level)
OR exists(SELECT 1 from tag_users tu
WHERE tu.user_id = :user_id AND
tu.tag_id IN (SELECT tag_id FROM topic_tags WHERE topic_id = :topic_id) AND
notification_level = :tag_level)",
user_id: user.id,
topic_id: topic.id,
category_id: topic.category_id,
topic_level: TopicUser.notification_levels[:watching],
category_level: CategoryUser.notification_levels[:watching],
tag_level: TagUser.notification_levels[:watching],
)
.where(topic_id: topic.id)
end
def first_unread_post(user, topic)
unread_posts(user, topic).order("post_number").first
end
def unread_count(user, topic)
unread_posts(user, topic).count
end
def destroy_notifications(user, types, topic)
return if user.blank?
return unless Guardian.new(user).can_see?(topic)
User.transaction do
user.notifications.where(notification_type: types, topic_id: topic.id).destroy_all
# Reload so notification counts sync up correctly
user.reload
end
end
NOTIFIABLE_TYPES =
%i[
mentioned
replied
quoted
posted
linked
private_message
group_mentioned
watching_first_post
event_reminder
event_invitation
].map { |t| Notification.types[t] }
def group_stats(topic)
sql = <<~SQL
SELECT COUNT(*) FROM topics t
JOIN topic_allowed_groups g ON g.group_id = :group_id AND g.topic_id = t.id
LEFT JOIN group_archived_messages a ON a.topic_id = t.id AND a.group_id = g.group_id
WHERE a.id IS NULL AND t.deleted_at is NULL AND t.archetype = 'private_message'
SQL
topic.allowed_groups.map do |g|
{
group_id: g.id,
group_name: g.name,
inbox_count: DB.query_single(sql, group_id: g.id).first.to_i,
}
end
end
def notify_group_summary(user, topic, acting_user_id: nil)
@group_stats ||= {}
stats = (@group_stats[topic.id] ||= group_stats(topic))
return unless stats
group_id = topic.topic_allowed_groups.where(group_id: user.groups.pluck(:id)).pick(:group_id)
stat = stats.find { |s| s[:group_id] == group_id }
return unless stat
DistributedMutex.synchronize("group_message_notify_#{user.id}") do
if stat[:inbox_count] > 0
Notification.consolidate_or_create!(
notification_type: Notification.types[:group_message_summary],
user_id: user.id,
read: user.id === acting_user_id ? true : false,
data: {
group_id: stat[:group_id],
group_name: stat[:group_name],
inbox_count: stat[:inbox_count],
username: user.username_lower,
}.to_json,
)
else
Notification
.where(user_id: user.id, notification_type: Notification.types[:group_message_summary])
.where("data::json ->> 'group_id' = ?", stat[:group_id].to_s)
.delete_all
end
end
# TODO decide if it makes sense to also publish a desktop notification
end
def should_notify_edit?(notification, post, opts)
notification.created_at < 1.day.ago ||
notification.data_hash["display_username"] !=
(opts[:display_username].presence || post.user.username)
end
def should_notify_like?(user, notification)
if user.user_option.like_notification_frequency ==
UserOption.like_notification_frequency_type[:always]
return true
end
if user.user_option.like_notification_frequency ==
UserOption.like_notification_frequency_type[:first_time_and_daily] &&
notification.created_at < 1.day.ago
return true
end
2018-05-15 03:51:32 -04:00
false
end
def should_notify_previous?(user, post, notification, opts)
case notification.notification_type
when Notification.types[:edited]
should_notify_edit?(notification, post, opts)
when Notification.types[:liked]
should_notify_like?(user, notification)
else
false
end
end
COLLAPSED_NOTIFICATION_TYPES ||= [
Notification.types[:replied],
Notification.types[:posted],
2018-12-24 06:44:50 -05:00
Notification.types[:private_message],
Notification.types[:watching_category_or_tag],
]
def create_notification(user, type, post, opts = {})
opts = @default_opts.merge(opts)
DiscourseEvent.trigger(:before_create_notification, user, type, post, opts)
return if user.blank? || user.bot? || post.blank?
return if (topic = post.topic).blank?
is_liked = type == Notification.types[:liked]
if is_liked &&
user.user_option.like_notification_frequency ==
UserOption.like_notification_frequency_type[:never]
return
end
return if !Guardian.new(user).can_receive_post_notifications?(post)
return if user.staged? && topic.category&.mailinglist_mirror?
notifier_id = opts[:user_id] || post.user_id # xxxxx look at revision history
if notifier_id &&
UserCommScreener.new(
acting_user_id: notifier_id,
target_user_ids: user.id,
).ignoring_or_muting_actor?(user.id)
return
end
# skip if muted on the topic
if TopicUser.where(
topic: topic,
user: user,
notification_level: TopicUser.notification_levels[:muted],
).exists?
return
end
# skip if muted on the group
if group = opts[:group]
if GroupUser.where(
group_id: opts[:group_id],
user_id: user.id,
notification_level: TopicUser.notification_levels[:muted],
).exists?
return
end
end
existing_notifications =
user
.notifications
.order("notifications.id DESC")
.where(topic_id: post.topic_id, post_number: post.post_number)
.limit(10)
# Don't notify the same user about the same type of notification on the same post
existing_notification_of_same_type =
existing_notifications.find { |n| n.notification_type == type }
if existing_notification_of_same_type &&
!should_notify_previous?(user, post, existing_notification_of_same_type, opts)
return
end
# linked, quoted, mentioned, chat_quoted may be suppressed if you already have a reply notification
if [
Notification.types[:quoted],
Notification.types[:linked],
Notification.types[:mentioned],
Notification.types[:chat_quoted],
].include?(type)
if existing_notifications.find { |n| n.notification_type == Notification.types[:replied] }
return
end
end
collapsed = false
if COLLAPSED_NOTIFICATION_TYPES.include?(type)
destroy_notifications(user, COLLAPSED_NOTIFICATION_TYPES, topic)
collapsed = true
end
original_post = post
2018-12-24 06:44:50 -05:00
original_username = opts[:display_username].presence || post.username
if collapsed
post = first_unread_post(user, topic) || post
count = unread_count(user, topic)
if count > 1
I18n.with_locale(user.effective_locale) do
opts[:display_username] = I18n.t("embed.replies", count: count)
end
end
end
UserActionManager.notification_created(original_post, user, type, opts[:acting_user_id])
topic_title = topic.title
# when sending a private message email, keep the original title
if topic.private_message? && modifications = post.revisions.map(&:modifications)
if first_title_modification = modifications.find { |m| m.has_key?("title") }
topic_title = first_title_modification["title"][0]
end
end
notification_data = {
topic_title: topic_title,
original_post_id: original_post.id,
original_post_type: original_post.post_type,
original_username: original_username,
revision_number: opts[:revision_number],
display_username: opts[:display_username] || post.user.username,
}
opts[:custom_data].each { |k, v| notification_data[k] = v } if opts[:custom_data]&.is_a?(Hash)
if group = opts[:group]
notification_data[:group_id] = group.id
notification_data[:group_name] = group.name
end
if opts[:skip_send_email_to]&.include?(user.email)
skip_send_email = true
elsif original_post.via_email && (incoming_email = original_post.incoming_email)
skip_send_email =
incoming_email.to_addresses_split.include?(user.email) ||
incoming_email.cc_addresses_split.include?(user.email)
else
skip_send_email = opts[:skip_send_email]
end
# Create the notification
REFACTOR: Improve support for consolidating notifications. (#14904) * REFACTOR: Improve support for consolidating notifications. Before this commit, we didn't have a single way of consolidating notifications. For notifications like group summaries, we manually removed old ones before creating a new one. On the other hand, we used an after_create callback for likes and group membership requests, which caused unnecessary work, as we need to delete the record we created to replace it with a consolidated one. We now have all the consolidation rules centralized in a single place: the consolidation planner class. Other parts of the app looking to create a consolidable notification can do so by calling Notification#consolidate_or_save!, instead of the default Notification#create! method. Finally, we added two more rules: one for re-using existing group summaries and another for deleting duplicated dashboard problems PMs notifications when the user is tracking the moderator's inbox. Setting the threshold to one forces the planner to apply this rule every time. I plan to add plugin support for adding custom rules in another PR to keep this one relatively small. * DEV: Introduces a plugin API for consolidating notifications. This commit removes the `Notification#filter_by_consolidation_data` scope since plugins could have to define their criteria. The Plan class now receives two blocks, one to query for an already consolidated notification, which we'll try to update, and another to query for existing ones to consolidate. It also receives a consolidation window, which accepts an ActiveSupport::Duration object, and filter notifications created since that value.
2021-11-30 11:36:14 -05:00
created =
user.notifications.consolidate_or_create!(
notification_type: type,
topic_id: post.topic_id,
post_number: post.post_number,
post_action_id: opts[:post_action_id],
data: notification_data.to_json,
skip_send_email: skip_send_email,
)
if created.id && existing_notifications.empty? && NOTIFIABLE_TYPES.include?(type)
create_notification_alert(
user: user,
post: original_post,
notification_type: type,
username: original_username,
)
end
created.id ? created : nil
end
def create_notification_alert(user:, post:, notification_type:, excerpt: nil, username: nil)
self.class.create_notification_alert(
user: user,
post: post,
notification_type: notification_type,
excerpt: excerpt,
username: username,
)
end
def push_notification(user, payload)
self.class.push_notification(user, payload)
end
def expand_group_mentions(groups, post)
return unless post.user && groups
Group
.mentionable(post.user, include_public: false)
.where(id: groups.map(&:id))
.each do |group|
next if group.user_count >= SiteSetting.max_users_notified_per_group_mention
yield group, group.users
end
end
def expand_here_mention(post, exclude_ids: nil)
posts = Post.where(topic_id: post.topic_id)
posts = posts.where.not(user_id: exclude_ids) if exclude_ids.present?
if post.user.staff?
posts = posts.where(post_type: [Post.types[:regular], Post.types[:whisper]])
else
posts = posts.where(post_type: Post.types[:regular])
end
User.real.where(id: posts.select(:user_id)).limit(SiteSetting.max_here_mentioned)
end
# TODO: Move to post-analyzer?
def extract_mentions(post)
mentions = post.raw_mentions
return if mentions.blank?
groups = Group.where("LOWER(name) IN (?)", mentions)
mentions -= groups.map(&:name).map(&:downcase)
groups = nil if groups.empty?
if mentions.present?
users =
User
.where(username_lower: mentions)
.includes(:do_not_disturb_timings)
.where.not(id: post.user_id)
users = nil if users.empty?
end
# @here can be a user mention and then this feature is disabled
here = mentions.include?(SiteSetting.here_mention) && Guardian.new(post.user).can_mention_here?
[groups, users, here]
end
# TODO: Move to post-analyzer?
# Returns a list of users who were quoted in the post
def extract_quoted_users(post)
usernames =
if SiteSetting.display_name_on_posts && !SiteSetting.prioritize_username_in_ux
post.raw.scan(/username:([[:alnum:]]*)"(?=\])/)
else
post.raw.scan(/\[quote=\"([^,]+),.+\"\]/)
end.uniq.map { |q| q.first.strip.downcase }
User.where.not(id: post.user_id).where(username_lower: usernames)
end
def extract_linked_users(post)
users =
post
.topic_links
.where(reflection: false)
.map do |link|
linked_post = link.link_post
if !linked_post && topic = link.link_topic
linked_post = topic.posts.find_by(post_number: 1)
end
(linked_post && post.user_id != linked_post.user_id && linked_post.user) || nil
end
.compact
DiscourseEvent.trigger(:after_extract_linked_users, users, post)
users
end
# Notify a bunch of users
def notify_non_pm_users(users, type, post, opts = {})
return [] if post.topic&.private_message?
2015-05-25 13:15:00 -04:00
notify_users(users, type, post, opts)
end
def notify_users(users, type, post, opts = {})
users = [users] unless users.is_a?(Array)
users.reject!(&:staged?) if post.topic&.private_message?
2015-05-25 13:15:00 -04:00
warn_if_not_sidekiq
DiscourseEvent.trigger(:before_create_notifications_for_users, users, post)
users.each { |u| create_notification(u, Notification.types[type], post, opts) }
users
end
def pm_watching_users(post)
return [] if !post.topic.private_message?
directly_targeted_users(post).filter do |u|
notification_level = TopicUser.get(post.topic, u)&.notification_level
notification_level == TopicUser.notification_levels[:watching]
end
end
def notify_pm_users(post, reply_to_user, quoted_users, notified)
return [] unless post.topic
warn_if_not_sidekiq
# To simplify things and to avoid IMAP double sync issues, and to cut down
# on emails sent via SMTP, any topic_allowed_users (except those who are
# not_allowed?) for a group that has SMTP enabled will have their notification
# email combined into one and sent via a single group SMTP email with CC addresses.
emails_to_skip_send = email_using_group_smtp_if_configured(post)
# We create notifications for all directly_targeted_users and email those
# who do _not_ have their email addresses in the emails_to_skip_send array
# (which will include all topic allowed users' email addresses if group SMTP
# is enabled).
users = directly_targeted_users(post).reject { |u| notified.include?(u) }
DiscourseEvent.trigger(:before_create_notifications_for_users, users, post)
users.each do |user|
if reply_to_user == user || pm_watching_users(post).include?(user) || user.staged?
create_notification(
user,
Notification.types[:private_message],
post,
skip_send_email_to: emails_to_skip_send,
)
2018-05-15 03:51:32 -04:00
end
end
2018-05-15 03:51:32 -04:00
# Users that are part of all mentioned groups. Emails sent by this notification
# flow will not be sent via group SMTP if it is enabled.
users = indirectly_targeted_users(post).reject { |u| notified.include?(u) }
DiscourseEvent.trigger(:before_create_notifications_for_users, users, post)
users.each do |user|
case TopicUser.get(post.topic, user)&.notification_level
when TopicUser.notification_levels[:watching]
create_pm_notification(user, post, emails_to_skip_send)
when TopicUser.notification_levels[:tracking]
if is_replying?(user, reply_to_user, quoted_users)
create_pm_notification(user, post, emails_to_skip_send)
else
notify_group_summary(user, post.topic)
end
when TopicUser.notification_levels[:regular]
if is_replying?(user, reply_to_user, quoted_users)
create_pm_notification(user, post, emails_to_skip_send)
end
2018-05-15 03:51:32 -04:00
end
end
end
def group_notifying_via_smtp(post)
return if !SiteSetting.enable_smtp || post.post_type != Post.types[:regular]
return if post.topic.allowed_groups.none?
return post.topic.first_smtp_enabled_group if post.topic.allowed_groups.count == 1
topic_incoming_email = post.topic.incoming_email.first
return if topic_incoming_email.blank?
group = Group.find_by_email(topic_incoming_email.to_addresses)
return post.topic.first_smtp_enabled_group if !group&.smtp_enabled
group
end
def email_using_group_smtp_if_configured(post)
emails_to_skip_send = []
group = group_notifying_via_smtp(post)
return emails_to_skip_send if group.blank?
to_address = nil
cc_addresses = []
# We need to use topic_allowed_users here instead of directly_targeted_users
# because we want to make sure the to_address goes to the OP of the topic.
topic_allowed_users_by_age =
post
.topic
.topic_allowed_users
.includes(:user)
.order(:created_at)
.reject { |tau| not_allowed?(tau.user, post) }
return emails_to_skip_send if topic_allowed_users_by_age.empty?
# This should usually be the OP of the topic, unless they are the one
# replying by email (they are excluded by not_allowed? then)
to_address = topic_allowed_users_by_age.first.user.email
cc_addresses = topic_allowed_users_by_age[1..-1].map { |tau| tau.user.email }
email_addresses = [to_address, cc_addresses].flatten
# If any of these email addresses were cc address on the
# incoming email for the target post, do not send them emails (they
# already have been notified by the CC on the email)
if post.incoming_email.present?
cc_addresses = cc_addresses - post.incoming_email.cc_addresses_split
# If the to address is one of the recently added CC addresses, then we
# need to bail early, because otherwise we are sending a notification
# email to the user who was just added by CC. In this case the OP probably
# replied and CC'd some people, and they are the only other topic users.
return if post.incoming_email.cc_addresses_split.include?(to_address)
# We don't want to create an email storm if someone emails the group and
# CC's 50 support addresses from various places, which all then respond
# with auto-responders saying they have received our email. Any auto-generated
# emails should not propagate notifications to anyone else, not even
# the regular topic user notifications.
return email_addresses.dup.uniq if post.incoming_email.is_auto_generated?
end
# Send a single email using group SMTP settings to cut down on the
# number of emails sent via SMTP, also to replicate how support systems
# and group inboxes generally work in other systems.
#
# We need to send this on a delay to allow for editing and finalising
# posts, the same way we do for private_message user emails/notifications.
Jobs.enqueue_in(
SiteSetting.personal_email_time_window_seconds,
:group_smtp_email,
group_id: group.id,
post_id: post.id,
email: to_address,
cc_emails: cc_addresses,
)
FEATURE: Use group SMTP settings for sending user notification emails (initial) (#13220) This PR changes the `UserNotification` class to send outbound `user_private_message` using the group's SMTP settings, but only if: * The first allowed_group on the topic has SMTP configured and enabled * SiteSetting.enable_smtp is true * The group does not have IMAP enabled, if this is enabled the `GroupSMTPMailer` handles things The email is sent using the group's `email_username` as both the `from` and `reply-to` address, so when the user replies from their email it will go through the group's SMTP inbox, which needs to have email forwarding set up to send the message on to a location (such as a hosted site email address like meta@discoursemail.com) where it can be POSTed into discourse's handle_mail route. Also includes a fix to `EmailReceiver#group_incoming_emails_regex` to include the `group.email_username` so the group does not get a staged user created and invited to the topic (which was a problem for IMAP), as well as updating `Group.find_by_email` to find using the `email_username` as well for inbound emails with that as the TO address. #### Note This is safe to merge without impacting anyone seriously. If people had SMTP enabled for a group they would have IMAP enabled too currently, and that is a very small amount of users because IMAP is an alpha product, and also because the UserNotification change has a guard to make sure it is not used if IMAP is enabled for the group. The existing IMAP tests work, and I tested this functionality by manually POSTing replies to the SMTP address into my local discourse. There will probably be more work needed on this, but it needs to be tested further in a real hosted environment to continue.
2021-06-03 00:47:32 -04:00
# Add the group's email_username into the array, because it is used for
# skip_send_email_to in the case of user private message notifications
# (we do not want the group to be sent any emails from here because it
# will make another email for IMAP to pick up in the group's mailbox)
emails_to_skip_send = email_addresses.dup if email_addresses.any?
emails_to_skip_send << group.email_username
emails_to_skip_send.uniq
end
def notify_post_users(
post,
notified,
group_ids: nil,
include_topic_watchers: true,
include_category_watchers: true,
include_tag_watchers: true,
new_record: false,
notification_type: nil
)
return [] unless post.topic
warn_if_not_sidekiq
condition = +<<~SQL
users.id IN (
SELECT id FROM users WHERE false
/*topic*/
/*category*/
/*tags*/
)
SQL
condition.sub! "/*topic*/", <<~SQL if include_topic_watchers
UNION
2018-05-15 03:51:32 -04:00
SELECT user_id
FROM topic_users
WHERE notification_level = :watching
AND topic_id = :topic_id
SQL
condition.sub! "/*category*/", <<~SQL if include_category_watchers
UNION
2018-05-15 03:51:32 -04:00
SELECT cu.user_id
FROM category_users cu
LEFT JOIN topic_users tu ON tu.user_id = cu.user_id
AND tu.topic_id = :topic_id
WHERE cu.notification_level = :watching
AND cu.category_id = :category_id
AND (tu.user_id IS NULL OR tu.notification_level = :watching)
SQL
tag_ids = post.topic.topic_tags.pluck("topic_tags.tag_id")
condition.sub! "/*tags*/", <<~SQL if include_tag_watchers && tag_ids.present?
2018-05-15 03:51:32 -04:00
UNION
SELECT tag_users.user_id
FROM tag_users
LEFT JOIN topic_users tu ON tu.user_id = tag_users.user_id
AND tu.topic_id = :topic_id
LEFT JOIN tag_group_memberships tgm ON tag_users.tag_id = tgm.tag_id
LEFT JOIN tag_group_permissions tgp ON tgm.tag_group_id = tgp.tag_group_id
LEFT JOIN group_users gu ON gu.user_id = tag_users.user_id
WHERE (
tgp.group_id IS NULL OR
tgp.group_id = gu.group_id OR
tgp.group_id = :everyone_group_id OR
gu.group_id = :staff_group_id
)
AND (tag_users.notification_level = :watching
AND tag_users.tag_id IN (:tag_ids)
AND (tu.user_id IS NULL OR tu.notification_level = :watching))
2018-05-15 03:51:32 -04:00
SQL
notify =
User.where(
condition,
2018-05-15 03:51:32 -04:00
watching: TopicUser.notification_levels[:watching],
topic_id: post.topic_id,
category_id: post.topic.category_id,
tag_ids: tag_ids,
staff_group_id: Group::AUTO_GROUPS[:staff],
everyone_group_id: Group::AUTO_GROUPS[:everyone],
2018-05-15 03:51:32 -04:00
)
if group_ids.present?
notify = notify.joins(:group_users).where("group_users.group_id IN (?)", group_ids)
end
notify = notify.where(staged: false).staff if post.topic.private_message?
exclude_user_ids = notified.map(&:id)
notify = notify.where("users.id NOT IN (?)", exclude_user_ids) if exclude_user_ids.present?
DiscourseEvent.trigger(:before_create_notifications_for_users, notify, post)
already_seen_user_ids =
Set.new(
TopicUser
.where(topic_id: post.topic.id)
.where("last_read_post_number >= ?", post.post_number)
.pluck(:user_id),
)
each_user_in_batches(notify) do |user|
calculated_type =
if !new_record && already_seen_user_ids.include?(user.id)
Notification.types[:edited]
elsif notification_type
Notification.types[notification_type]
else
Notification.types[:posted]
end
opts = {}
opts[:display_username] = post.last_editor.username if calculated_type ==
Notification.types[:edited]
create_notification(user, calculated_type, post, opts)
end
notify
end
def warn_if_not_sidekiq
unless Sidekiq.server?
Rails.logger.warn(
"PostAlerter.#{caller_locations(1, 1)[0].label} was called outside of sidekiq",
)
end
end
private
def each_user_in_batches(users)
# This is race-condition-safe, unlike #find_in_batches
users
.pluck(:id)
.each_slice(USER_BATCH_SIZE) do |user_ids_batch|
User.where(id: user_ids_batch).includes(:do_not_disturb_timings).each { |user| yield(user) }
end
end
def create_pm_notification(user, post, emails_to_skip_send)
create_notification(
user,
Notification.types[:private_message],
post,
skip_send_email_to: emails_to_skip_send,
)
end
def is_replying?(user, reply_to_user, quoted_users)
reply_to_user == user || quoted_users.include?(user)
end
def user_watching_topic?(user, topic)
TopicUser.exists?(
user_id: user.id,
topic_id: topic.id,
notification_level: TopicUser.notification_levels[:watching],
)
end
end