mirror of
https://github.com/discourse/discourse.git
synced 2024-11-25 18:30:26 -06:00
312 lines
9.5 KiB
Ruby
312 lines
9.5 KiB
Ruby
require_dependency 'new_post_manager'
|
|
require_dependency 'email/html_cleaner'
|
|
|
|
module Email
|
|
|
|
class Receiver
|
|
|
|
include ActionView::Helpers::NumberHelper
|
|
|
|
class ProcessingError < StandardError; end
|
|
class EmailUnparsableError < ProcessingError; end
|
|
class EmptyEmailError < ProcessingError; end
|
|
class UserNotFoundError < ProcessingError; end
|
|
class UserNotSufficientTrustLevelError < ProcessingError; end
|
|
class BadDestinationAddress < ProcessingError; end
|
|
class TopicNotFoundError < ProcessingError; end
|
|
class TopicClosedError < ProcessingError; end
|
|
class AutoGeneratedEmailError < ProcessingError; end
|
|
class EmailLogNotFound < ProcessingError; end
|
|
class InvalidPost < ProcessingError; end
|
|
|
|
attr_reader :body, :email_log
|
|
|
|
def initialize(raw, opts=nil)
|
|
@raw = raw
|
|
@opts = opts || {}
|
|
end
|
|
|
|
def process
|
|
raise EmptyEmailError if @raw.blank?
|
|
|
|
message = Mail.new(@raw)
|
|
|
|
body = parse_body(message)
|
|
|
|
dest_info = { type: :invalid, obj: nil }
|
|
message.to.each do |to_address|
|
|
dest_info = check_address(to_address)
|
|
break if dest_info[:type] != :invalid
|
|
end
|
|
|
|
raise BadDestinationAddress if dest_info[:type] == :invalid
|
|
raise AutoGeneratedEmailError if message.header.to_s =~ /auto-generated/ || message.header.to_s =~ /auto-replied/
|
|
|
|
# TODO get to a state where we can remove this
|
|
@message = message
|
|
@body = body
|
|
|
|
user_email = @message.from.first
|
|
@user = User.find_by_email(user_email)
|
|
|
|
case dest_info[:type]
|
|
when :group
|
|
raise BadDestinationAddress unless SiteSetting.email_in
|
|
group = dest_info[:obj]
|
|
|
|
if @user.blank?
|
|
if SiteSetting.allow_staged_accounts
|
|
@user = create_staged_account(user_email)
|
|
else
|
|
wrap_body_in_quote(user_email)
|
|
@user = Discourse.system_user
|
|
end
|
|
end
|
|
|
|
raise UserNotFoundError if @user.blank?
|
|
raise UserNotSufficientTrustLevelError.new(@user) unless @user.has_trust_level?(TrustLevel[SiteSetting.email_in_min_trust.to_i])
|
|
|
|
create_new_topic(archetype: Archetype.private_message, target_group_names: [group.name])
|
|
when :category
|
|
raise BadDestinationAddress unless SiteSetting.email_in
|
|
category = dest_info[:obj]
|
|
|
|
if @user.blank? && category.email_in_allow_strangers
|
|
if SiteSetting.allow_staged_accounts
|
|
@user = create_staged_account(user_email)
|
|
else
|
|
wrap_body_in_quote(user_email)
|
|
@user = Discourse.system_user
|
|
end
|
|
end
|
|
|
|
raise UserNotFoundError if @user.blank?
|
|
raise UserNotSufficientTrustLevelError.new(@user) unless category.email_in_allow_strangers || @user.has_trust_level?(TrustLevel[SiteSetting.email_in_min_trust.to_i])
|
|
|
|
create_new_topic(category: category.id)
|
|
when :reply
|
|
@email_log = dest_info[:obj]
|
|
|
|
raise EmailLogNotFound if @email_log.blank?
|
|
raise TopicNotFoundError if Topic.find_by_id(@email_log.topic_id).nil?
|
|
raise TopicClosedError if Topic.find_by_id(@email_log.topic_id).closed?
|
|
|
|
create_reply
|
|
end
|
|
|
|
rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError => e
|
|
raise EmailUnparsableError.new(e)
|
|
end
|
|
|
|
def create_staged_account(email)
|
|
User.create(
|
|
email: email,
|
|
username: UserNameSuggester.suggest(email),
|
|
name: User.suggest_name(email),
|
|
staged: true
|
|
)
|
|
end
|
|
|
|
def check_address(address)
|
|
group = Group.find_by_email(address)
|
|
return { type: :group, obj: group } if group
|
|
|
|
category = Category.find_by_email(address)
|
|
return { type: :category, obj: category } if category
|
|
|
|
regex = Regexp.escape(SiteSetting.reply_by_email_address)
|
|
regex = regex.gsub(Regexp.escape('%{reply_key}'), "(.*)")
|
|
regex = Regexp.new(regex)
|
|
match = regex.match address
|
|
if match && match[1].present?
|
|
reply_key = match[1]
|
|
email_log = EmailLog.for(reply_key)
|
|
return { type: :reply, obj: email_log }
|
|
end
|
|
|
|
{ type: :invalid, obj: nil }
|
|
end
|
|
|
|
def parse_body(message)
|
|
body = select_body message
|
|
encoding = body.encoding
|
|
raise EmptyEmailError if body.strip.blank?
|
|
|
|
body = discourse_email_trimmer body
|
|
raise EmptyEmailError if body.strip.blank?
|
|
|
|
body = EmailReplyParser.parse_reply body
|
|
raise EmptyEmailError if body.strip.blank?
|
|
|
|
body.force_encoding(encoding).encode("UTF-8")
|
|
end
|
|
|
|
def select_body(message)
|
|
html = nil
|
|
|
|
if message.multipart?
|
|
text = fix_charset message.text_part
|
|
# prefer text over html
|
|
return text if text
|
|
html = fix_charset message.html_part
|
|
elsif message.content_type =~ /text\/html/
|
|
html = fix_charset message
|
|
end
|
|
|
|
if html
|
|
body = HtmlCleaner.new(html).output_html
|
|
else
|
|
body = fix_charset message
|
|
end
|
|
|
|
return body if @opts[:skip_sanity_check]
|
|
|
|
# Certain trigger phrases that means we didn't parse correctly
|
|
if body =~ /Content\-Type\:/ || body =~ /multipart\/alternative/ || body =~ /text\/plain/
|
|
raise EmptyEmailError
|
|
end
|
|
|
|
body
|
|
end
|
|
|
|
# Force encoding to UTF-8 on a Mail::Message or Mail::Part
|
|
def fix_charset(object)
|
|
return nil if object.nil?
|
|
|
|
if object.charset
|
|
object.body.decoded.force_encoding(object.charset.gsub(/utf8/i, "UTF-8")).encode("UTF-8").to_s
|
|
else
|
|
object.body.to_s
|
|
end
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
REPLYING_HEADER_LABELS = ['From', 'Sent', 'To', 'Subject', 'Reply To', 'Cc', 'Bcc', 'Date']
|
|
REPLYING_HEADER_REGEX = Regexp.union(REPLYING_HEADER_LABELS.map { |lbl| "#{lbl}:" })
|
|
|
|
def line_is_quote?(l)
|
|
l =~ /\A\s*\-{3,80}\s*\z/ ||
|
|
l =~ Regexp.new("\\A\\s*" + I18n.t('user_notifications.previous_discussion') + "\\s*\\Z") ||
|
|
(l =~ /via #{SiteSetting.title}(.*)\:$/) ||
|
|
# This one might be controversial but so many reply lines have years, times and end with a colon.
|
|
# Let's try it and see how well it works.
|
|
(l =~ /\d{4}/ && l =~ /\d:\d\d/ && l =~ /\:$/) ||
|
|
(l =~ /On [\w, ]+\d+.*wrote:/)
|
|
end
|
|
|
|
def discourse_email_trimmer(body)
|
|
lines = body.scrub.lines.to_a
|
|
range_start = 0
|
|
range_end = 0
|
|
|
|
# If we started with a quote, skip it
|
|
lines.each_with_index do |l, idx|
|
|
break unless line_is_quote?(l) or l =~ /^>/ or l.blank?
|
|
range_start = idx + 1
|
|
end
|
|
|
|
lines[range_start..-1].each_with_index do |l, idx|
|
|
break if line_is_quote?(l)
|
|
|
|
# Headers on subsequent lines
|
|
break if (0..2).all? { |off| lines[idx+off] =~ REPLYING_HEADER_REGEX }
|
|
# Headers on the same line
|
|
break if REPLYING_HEADER_LABELS.count { |lbl| l.include? lbl } >= 3
|
|
range_end = range_start + idx
|
|
end
|
|
|
|
lines[range_start..range_end].join.strip
|
|
end
|
|
|
|
private
|
|
|
|
def wrap_body_in_quote(user_email)
|
|
@body = "[quote=\"#{user_email}\"]\n#{@body}\n[/quote]"
|
|
end
|
|
|
|
def create_reply
|
|
create_post_with_attachments(@email_log.user,
|
|
raw: @body,
|
|
topic_id: @email_log.topic_id,
|
|
reply_to_post_number: @email_log.post.post_number)
|
|
end
|
|
|
|
def create_new_topic(topic_options={})
|
|
topic_options[:raw] = @body
|
|
topic_options[:title] = @message.subject
|
|
|
|
result = create_post_with_attachments(@user, topic_options)
|
|
topic_id = result.post.present? ? result.post.topic_id : nil
|
|
|
|
EmailLog.create(
|
|
email_type: "topic_via_incoming_email",
|
|
to_address: @message.from.first, # pick from address because we want the user's email
|
|
topic_id: topic_id,
|
|
user_id: @user.id,
|
|
)
|
|
|
|
result
|
|
end
|
|
|
|
def create_post_with_attachments(user, post_options={})
|
|
options = {
|
|
cooking_options: { traditional_markdown_linebreaks: true },
|
|
}.merge(post_options)
|
|
|
|
raw = options[:raw]
|
|
|
|
# deal with attachments
|
|
@message.attachments.each do |attachment|
|
|
tmp = Tempfile.new("discourse-email-attachment")
|
|
begin
|
|
# read attachment
|
|
File.open(tmp.path, "w+b") { |f| f.write attachment.body.decoded }
|
|
# create the upload for the user
|
|
upload = Upload.create_for(user.id, tmp, attachment.filename, tmp.size)
|
|
if upload && upload.errors.empty?
|
|
# try to inline images
|
|
if attachment.content_type.start_with?("image/")
|
|
if raw =~ /\[image: Inline image \d+\]/
|
|
raw.sub!(/\[image: Inline image \d+\]/, attachment_markdown(upload))
|
|
next
|
|
end
|
|
end
|
|
raw << "\n#{attachment_markdown(upload)}\n"
|
|
end
|
|
ensure
|
|
tmp.close!
|
|
end
|
|
end
|
|
|
|
options[:raw] = raw
|
|
|
|
create_post(user, options)
|
|
end
|
|
|
|
def attachment_markdown(upload)
|
|
if FileHelper.is_image?(upload.original_filename)
|
|
"<img src='#{upload.url}' width='#{upload.width}' height='#{upload.height}'>"
|
|
else
|
|
"<a class='attachment' href='#{upload.url}'>#{upload.original_filename}</a> (#{number_to_human_size(upload.filesize)})"
|
|
end
|
|
end
|
|
|
|
def create_post(user, options)
|
|
# Mark the reply as incoming via email
|
|
options[:via_email] = true
|
|
options[:raw_email] = @raw
|
|
|
|
manager = NewPostManager.new(user, options)
|
|
result = manager.perform
|
|
|
|
if result.errors.present?
|
|
raise InvalidPost, result.errors.full_messages.join("\n")
|
|
end
|
|
|
|
result
|
|
end
|
|
|
|
end
|
|
end
|