Class: Mailer

Inherits:
ActionMailer::Base
  • Object
show all
Includes:
Redmine::I18n, Roadie::Rails::Automatic
Defined in:
app/models/mailer.rb

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Redmine::I18n

#current_language, #day_letter, #day_name, #find_language, #format_date, #format_hours, #format_time, included, #l, #l_hours, #l_hours_short, #l_or_humanize, #languages_options, #ll, #lu, #month_name, #set_language_if_valid, #valid_languages

Constructor Details

#initialize(*args) ⇒ Mailer

Returns a new instance of Mailer



491
492
493
494
495
 
# File 'app/models/mailer.rb', line 491

def initialize(*args)
  @initial_language = current_language
  set_language_if_valid Setting.default_language
  super
end

Class Method Details

.default_url_options ⇒ Object 



29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'app/models/mailer.rb', line 29

def self.default_url_options
  options = {:protocol => Setting.protocol}
  if Setting.host_name.to_s =~ /\A(https?\:\/\/)?(.+?)(\:(\d+))?(\/.+)?\z/i
    host, port, prefix = $2, $4, $5
    options.merge!({
      :host => host, :port => port, :script_name => prefix
    })
  else
    options[:host] = Setting.host_name
  end
  options
end

.deliver_issue_add(issue) ⇒ Object

Notifies users about a new issue



60
61
62
63
64
65
66
 
# File 'app/models/mailer.rb', line 60

def self.deliver_issue_add(issue)
  to = issue.notified_users
  cc = issue.notified_watchers - to
  issue.each_notification(to + cc) do |users|
    Mailer.issue_add(issue, to & users, cc & users).deliver
  end
end

.deliver_issue_edit(journal) ⇒ Object

Notifies users about an issue update



92
93
94
95
96
97
98
99
100
101
 
# File 'app/models/mailer.rb', line 92

def self.deliver_issue_edit(journal)
  issue = journal.journalized.reload
  to = journal.notified_users
  cc = journal.notified_watchers - to
  journal.each_notification(to + cc) do |users|
    issue.each_notification(users) do |users2|
      Mailer.issue_edit(journal, to & users2, cc & users2).deliver
    end
  end
end

.deliver_mail(mail) ⇒ Object 



497
498
499
500
501
502
503
504
505
506
507
508
509
510
 
# File 'app/models/mailer.rb', line 497

def self.deliver_mail(mail)
  return false if mail.to.blank? && mail.cc.blank? && mail.bcc.blank?
  begin
    # Log errors when raise_delivery_errors is set to false, Rails does not
    mail.raise_delivery_errors = true
    super
  rescue Exception => e
    if ActionMailer::Base.raise_delivery_errors
      raise e
    else
      Rails.logger.error "Email delivery error: #{e.message}"
    end
  end
end

.email_addresses(arg) ⇒ Object

Returns an array of email addresses to notify by replacing users in arg with their notified email addresses

Example:

Mailer.email_addresses(users)
=> ["foo@example.net", "bar@example.net"]


527
528
529
530
531
532
533
534
535
536
537
538
 
# File 'app/models/mailer.rb', line 527

def self.email_addresses(arg)
  arr = Array.wrap(arg)
  mails = arr.reject {|a| a.is_a? Principal}
  users = arr - mails
  if users.any?
    mails += EmailAddress.
      where(:user_id => users.map(&:id)).
      where("is_default = ? OR notify = ?", true, true).
      pluck(:address)
  end
  mails
end

.method_missing(method, *args, &block) ⇒ Object 



512
513
514
515
516
517
518
519
 
# File 'app/models/mailer.rb', line 512

def self.method_missing(method, *args, &block)
  if m = method.to_s.match(%r{^deliver_(.+)$})
    ActiveSupport::Deprecation.warn "Mailer.deliver_#{m[1]}(*args) is deprecated. Use Mailer.#{m[1]}(*args).deliver instead."
    send(m[1], *args).deliver
  else
    super
  end
end

.password_updated(user) ⇒ Object

Notifies user that his password was updated



314
315
316
317
318
319
320
321
322
323
324
325
 
# File 'app/models/mailer.rb', line 314

def self.password_updated(user)
  # Don't send a notification to the dummy email address when changing the password
  # of the default admin account which is required after the first login
  # TODO: maybe not the best way to handle this
  return if user.admin? && user. == 'admin' && user.mail == 'admin@example.net'

  Mailer.security_notification(user,
    message: :mail_body_password_updated,
    title: :button_change_password,
    url: {controller: 'my', action: 'password'}
  ).deliver
end

.reminders(options = {}) ⇒ Object

Sends reminders to issue assignees Available options:

  • :days => how many days in the future to remind about (defaults to 7)

  • :tracker => id of tracker for filtering issues (defaults to all trackers)

  • :project => id or identifier of project to process (defaults to all projects)

  • :users => array of user/group ids who should be reminded

  • :version => name of target version for filtering issues (defaults to none)



379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
 
# File 'app/models/mailer.rb', line 379

def self.reminders(options={})
  days = options[:days] || 7
  project = options[:project] ? Project.find(options[:project]) : nil
  tracker = options[:tracker] ? Tracker.find(options[:tracker]) : nil
  target_version_id = options[:version] ? Version.named(options[:version]).pluck(:id) : nil
  if options[:version] && target_version_id.blank?
    raise ActiveRecord::RecordNotFound.new("Couldn't find Version with named #{options[:version]}")
  end
  user_ids = options[:users]

  scope = Issue.open.where("#{Issue.table_name}.assigned_to_id IS NOT NULL" +
    " AND #{Project.table_name}.status = #{Project::STATUS_ACTIVE}" +
    " AND #{Issue.table_name}.due_date <= ?", days.day.from_now.to_date
  )
  scope = scope.where(:assigned_to_id => user_ids) if user_ids.present?
  scope = scope.where(:project_id => project.id) if project
  scope = scope.where(:fixed_version_id => target_version_id) if target_version_id.present?
  scope = scope.where(:tracker_id => tracker.id) if tracker
  issues_by_assignee = scope.includes(:status, :assigned_to, :project, :tracker).
                            group_by(&:assigned_to)
  issues_by_assignee.keys.each do |assignee|
    if assignee.is_a?(Group)
      assignee.users.each do |user|
        issues_by_assignee[user] ||= []
        issues_by_assignee[user] += issues_by_assignee[assignee]
      end
    end
  end

  issues_by_assignee.each do |assignee, issues|
    reminder(assignee, issues, days).deliver if assignee.is_a?(User) && assignee.active?
  end
end

.security_settings_updated(changes) ⇒ Object

Notifies admins about settings changes



358
359
360
361
362
363
 
# File 'app/models/mailer.rb', line 358

def self.security_settings_updated(changes)
  return unless changes.present?

  users = User.active.where(admin: true).to_a
  Mailer.settings_updated(users, changes).deliver
end

.with_deliveries(enabled = true, &block) ⇒ Object

Activates/desactivates email deliveries during block



414
415
416
417
418
419
420
 
# File 'app/models/mailer.rb', line 414

def self.with_deliveries(enabled = true, &block)
  was_enabled = ActionMailer::Base.perform_deliveries
  ActionMailer::Base.perform_deliveries = !!enabled
  yield
ensure
  ActionMailer::Base.perform_deliveries = was_enabled
end

.with_synched_deliveries(&block) ⇒ Object

Sends emails synchronously in the given block



423
424
425
426
427
428
429
430
431
432
433
 
# File 'app/models/mailer.rb', line 423

def self.with_synched_deliveries(&block)
  saved_method = ActionMailer::Base.delivery_method
  if m = saved_method.to_s.match(%r{^async_(.+)$})
    synched_method = m[1]
    ActionMailer::Base.delivery_method = synched_method.to_sym
    ActionMailer::Base.send "#{synched_method}_settings=", ActionMailer::Base.send("async_#{synched_method}_settings")
  end
  yield
ensure
  ActionMailer::Base.delivery_method = saved_method
end

Instance Method Details

#account_activated(user) ⇒ Object

Builds a Mail::Message object used to email the specified user that their account was activated by an administrator.

Example:

account_activated(user) => Mail::Message object
Mailer.account_activated(user).deliver => sends an email to the registered user


296
297
298
299
300
301
302
 
# File 'app/models/mailer.rb', line 296

def (user)
  set_language_if_valid user.language
  @user = user
  @login_url = url_for(:controller => 'account', :action => 'login')
  mail :to => user.mail,
    :subject => l(:mail_subject_register, Setting.app_title)
end

#account_activation_request(user) ⇒ Object

Builds a Mail::Message object used to email all active administrators of an account activation request.

Example:

account_activation_request(user) => Mail::Message object
Mailer.account_activation_request(user).deliver => sends an email to all active administrators


280
281
282
283
284
285
286
287
288
289
 
# File 'app/models/mailer.rb', line 280

def (user)
  # Send the email to all active administrators
  recipients = User.active.where(:admin => true)
  @user = user
  @url = url_for(:controller => 'users', :action => 'index',
                       :status => User::STATUS_REGISTERED,
                       :sort_key => 'created_on', :sort_order => 'desc')
  mail :to => recipients,
    :subject => l(:mail_subject_account_activation_request, Setting.app_title)
end

#account_information(user, password) ⇒ Object

Builds a Mail::Message object used to email the specified user their account information.

Example:

account_information(user, password) => Mail::Message object
Mailer.account_information(user, password).deliver => sends account information to the user


266
267
268
269
270
271
272
273
 
# File 'app/models/mailer.rb', line 266

def (user, password)
  set_language_if_valid user.language
  @user = user
  @password = password
  @login_url = url_for(:controller => 'account', :action => 'login')
  mail :to => user.mail,
    :subject => l(:mail_subject_register, Setting.app_title)
end

#attachments_added(attachments) ⇒ Object

Builds a Mail::Message object used to email recipients of a project when an attachements are added.

Example:

attachments_added(attachments) => Mail::Message object
Mailer.attachments_added(attachments).deliver => sends an email to the project's recipients


133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'app/models/mailer.rb', line 133

def attachments_added(attachments)
  container = attachments.first.container
  added_to = ''
  added_to_url = ''
  @author = attachments.first.author
  case container.class.name
  when 'Project'
    added_to_url = url_for(:controller => 'files', :action => 'index', :project_id => container)
    added_to = "#{l(:label_project)}: #{container}"
    recipients = container.project.notified_users.select {|user| user.allowed_to?(:view_files, container.project)}
  when 'Version'
    added_to_url = url_for(:controller => 'files', :action => 'index', :project_id => container.project)
    added_to = "#{l(:label_version)}: #{container.name}"
    recipients = container.project.notified_users.select {|user| user.allowed_to?(:view_files, container.project)}
  when 'Document'
    added_to_url = url_for(:controller => 'documents', :action => 'show', :id => container.id)
    added_to = "#{l(:label_document)}: #{container.title}"
    recipients = container.notified_users
  end
  redmine_headers 'Project' => container.project.identifier
  @attachments = attachments
  @added_to = added_to
  @added_to_url = added_to_url
  mail :to => recipients,
    :subject => "[#{container.project.name}] #{l(:label_attachment_new)}"
end

#document_added(document) ⇒ Object

Builds a Mail::Message object used to email users belonging to the added document's project.

Example:

document_added(document) => Mail::Message object
Mailer.document_added(document).deliver => sends an email to the document's project recipients


119
120
121
122
123
124
125
126
 
# File 'app/models/mailer.rb', line 119

def document_added(document)
  redmine_headers 'Project' => document.project.identifier
  @author = User.current
  @document = document
  @document_url = url_for(:controller => 'documents', :action => 'show', :id => document)
  mail :to => document.notified_users,
    :subject => "[#{document.project.name}] #{l(:label_document_new)}: #{document.title}"
end

#issue_add(issue, to_users, cc_users) ⇒ Object

Builds a mail for notifying to_users and cc_users about a new issue



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'app/models/mailer.rb', line 43

def issue_add(issue, to_users, cc_users)
  redmine_headers 'Project' => issue.project.identifier,
                  'Issue-Id' => issue.id,
                  'Issue-Author' => issue.author.
  redmine_headers 'Issue-Assignee' => issue.assigned_to. if issue.assigned_to
  message_id issue
  references issue
  @author = issue.author
  @issue = issue
  @users = to_users + cc_users
  @issue_url = url_for(:controller => 'issues', :action => 'show', :id => issue)
  mail :to => to_users,
    :cc => cc_users,
    :subject => "[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}] (#{issue.status.name}) #{issue.subject}"
end

#issue_edit(journal, to_users, cc_users) ⇒ Object

Builds a mail for notifying to_users and cc_users about an issue update



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'app/models/mailer.rb', line 69

def issue_edit(journal, to_users, cc_users)
  issue = journal.journalized
  redmine_headers 'Project' => issue.project.identifier,
                  'Issue-Id' => issue.id,
                  'Issue-Author' => issue.author.
  redmine_headers 'Issue-Assignee' => issue.assigned_to. if issue.assigned_to
  message_id journal
  references issue
  @author = journal.user
  s = "[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}] "
  s << "(#{issue.status.name}) " if journal.new_value_for('status_id')
  s << issue.subject
  @issue = issue
  @users = to_users + cc_users
  @journal = journal
  @journal_details = journal.visible_details(@users.first)
  @issue_url = url_for(:controller => 'issues', :action => 'show', :id => issue, :anchor => "change-#{journal.id}")
  mail :to => to_users,
    :cc => cc_users,
    :subject => s
end

#lost_password(token, recipient = nil) ⇒ Object 



304
305
306
307
308
309
310
311
 
# File 'app/models/mailer.rb', line 304

def lost_password(token, recipient=nil)
  set_language_if_valid(token.user.language)
  recipient ||= token.user.mail
  @token = token
  @url = url_for(:controller => 'account', :action => 'lost_password', :token => token.value)
  mail :to => recipient,
    :subject => l(:mail_subject_lost_password, Setting.app_title)
end

#mail(headers = {}, &block) ⇒ Object 



435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
 
# File 'app/models/mailer.rb', line 435

def mail(headers={}, &block)
  headers.reverse_merge! 'X-Mailer' => 'Redmine',
          'X-Redmine-Host' => Setting.host_name,
          'X-Redmine-Site' => Setting.app_title,
          'X-Auto-Response-Suppress' => 'All',
          'Auto-Submitted' => 'auto-generated',
          'From' => Setting.mail_from,
          'List-Id' => "<#{Setting.mail_from.to_s.gsub('@', '.')}>"

  # Replaces users with their email addresses
  [:to, :cc, :bcc].each do |key|
    if headers[key].present?
      headers[key] = self.class.email_addresses(headers[key])
    end
  end

  # Removes the author from the recipients and cc
  # if the author does not want to receive notifications
  # about what the author do
  if @author && @author.logged? && @author.pref.no_self_notified
    addresses = @author.mails
    headers[:to] -= addresses if headers[:to].is_a?(Array)
    headers[:cc] -= addresses if headers[:cc].is_a?(Array)
  end

  if @author && @author.logged?
    redmine_headers 'Sender' => @author.
  end

  # Blind carbon copy recipients
  if Setting.bcc_recipients?
    headers[:bcc] = [headers[:to], headers[:cc]].flatten.uniq.reject(&:blank?)
    headers[:to] = nil
    headers[:cc] = nil
  end

  if @message_id_object
    headers[:message_id] = "<#{self.class.message_id_for(@message_id_object)}>"
  end
  if @references_objects
    headers[:references] = @references_objects.collect {|o| "<#{self.class.references_for(o)}>"}.join(' ')
  end

  m = if block_given?
    super headers, &block
  else
    super headers do |format|
      format.text
      format.html unless Setting.plain_text_mail?
    end
  end
  set_language_if_valid @initial_language

  m
end

#message_posted(message) ⇒ Object

Builds a Mail::Message object used to email the recipients of the specified message that was posted.

Example:

message_posted(message) => Mail::Message object
Mailer.message_posted(message).deliver => sends an email to the recipients


201
202
203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'app/models/mailer.rb', line 201

def message_posted(message)
  redmine_headers 'Project' => message.project.identifier,
                  'Topic-Id' => (message.parent_id || message.id)
  @author = message.author
  message_id message
  references message.root
  recipients = message.notified_users
  cc = ((message.root.notified_watchers + message.board.notified_watchers).uniq - recipients)
  @message = message
  @message_url = url_for(message.event_url)
  mail :to => recipients,
    :cc => cc,
    :subject => "[#{message.board.project.name} - #{message.board.name} - msg#{message.root.id}] #{message.subject}"
end

#news_added(news) ⇒ Object

Builds a Mail::Message object used to email recipients of a news' project when a news item is added.

Example:

news_added(news) => Mail::Message object
Mailer.news_added(news).deliver => sends an email to the news' project recipients


165
166
167
168
169
170
171
172
173
174
175
 
# File 'app/models/mailer.rb', line 165

def news_added(news)
  redmine_headers 'Project' => news.project.identifier
  @author = news.author
  message_id news
  references news
  @news = news
  @news_url = url_for(:controller => 'news', :action => 'show', :id => news)
  mail :to => news.notified_users,
    :cc => news.notified_watchers_for_added_news,
    :subject => "[#{news.project.name}] #{l(:label_news)}: #{news.title}"
end

#news_comment_added(comment) ⇒ Object

Builds a Mail::Message object used to email recipients of a news' project when a news comment is added.

Example:

news_comment_added(comment) => Mail::Message object
Mailer.news_comment_added(comment) => sends an email to the news' project recipients


182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'app/models/mailer.rb', line 182

def news_comment_added(comment)
  news = comment.commented
  redmine_headers 'Project' => news.project.identifier
  @author = comment.author
  message_id comment
  references news
  @news = news
  @comment = comment
  @news_url = url_for(:controller => 'news', :action => 'show', :id => news)
  mail :to => news.notified_users,
   :cc => news.notified_watchers,
   :subject => "Re: [#{news.project.name}] #{l(:label_news)}: #{news.title}"
end

#register(token) ⇒ Object 



327
328
329
330
331
332
333
 
# File 'app/models/mailer.rb', line 327

def register(token)
  set_language_if_valid(token.user.language)
  @token = token
  @url = url_for(:controller => 'account', :action => 'activate', :token => token.value)
  mail :to => token.user.mail,
    :subject => l(:mail_subject_register, Setting.app_title)
end

#reminder(user, issues, days) ⇒ Object 



103
104
105
106
107
108
109
110
111
112
 
# File 'app/models/mailer.rb', line 103

def reminder(user, issues, days)
  set_language_if_valid user.language
  @issues = issues
  @days = days
  @issues_url = url_for(:controller => 'issues', :action => 'index',
                              :set_filter => 1, :assigned_to_id => user.id,
                              :sort => 'due_date:asc')
  mail :to => user,
    :subject => l(:mail_subject_reminder, :count => issues.size, :days => days)
end

#security_notification(recipients, options = {}) ⇒ Object 



335
336
337
338
339
340
341
342
343
344
345
346
347
 
# File 'app/models/mailer.rb', line 335

def security_notification(recipients, options={})
  redmine_headers 'Sender' => User.current.
  @user = Array(recipients).detect{|r| r.is_a? User }
  set_language_if_valid(@user.try :language)
  @message = l(options[:message],
    field: (options[:field] && l(options[:field])),
    value: options[:value]
  )
  @title = options[:title] && l(options[:title])
  @url = options[:url] && (options[:url].is_a?(Hash) ? url_for(options[:url]) : options[:url])
  mail :to => recipients,
    :subject => "[#{Setting.app_title}] #{l(:mail_subject_security_notification)}"
end

#settings_updated(recipients, changes) ⇒ Object 



349
350
351
352
353
354
355
 
# File 'app/models/mailer.rb', line 349

def settings_updated(recipients, changes)
  redmine_headers 'Sender' => User.current.
  @changes = changes
  @url = url_for(controller: 'settings', action: 'index')
  mail :to => recipients,
    :subject => "[#{Setting.app_title}] #{l(:mail_subject_security_notification)}"
end

#test_email(user) ⇒ Object 



365
366
367
368
369
370
 
# File 'app/models/mailer.rb', line 365

def test_email(user)
  set_language_if_valid(user.language)
  @url = url_for(:controller => 'welcome')
  mail :to => user.mail,
    :subject => 'Redmine test'
end

#wiki_content_added(wiki_content) ⇒ Object

Builds a Mail::Message object used to email the recipients of a project of the specified wiki content was added.

Example:

wiki_content_added(wiki_content) => Mail::Message object
Mailer.wiki_content_added(wiki_content).deliver => sends an email to the project's recipients


221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
 
# File 'app/models/mailer.rb', line 221

def wiki_content_added(wiki_content)
  redmine_headers 'Project' => wiki_content.project.identifier,
                  'Wiki-Page-Id' => wiki_content.page.id
  @author = wiki_content.author
  message_id wiki_content
  recipients = wiki_content.notified_users
  cc = wiki_content.page.wiki.notified_watchers - recipients
  @wiki_content = wiki_content
  @wiki_content_url = url_for(:controller => 'wiki', :action => 'show',
                                    :project_id => wiki_content.project,
                                    :id => wiki_content.page.title)
  mail :to => recipients,
    :cc => cc,
    :subject => "[#{wiki_content.project.name}] #{l(:mail_subject_wiki_content_added, :id => wiki_content.page.pretty_title)}"
end

#wiki_content_updated(wiki_content) ⇒ Object

Builds a Mail::Message object used to email the recipients of a project of the specified wiki content was updated.

Example:

wiki_content_updated(wiki_content) => Mail::Message object
Mailer.wiki_content_updated(wiki_content).deliver => sends an email to the project's recipients


242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
 
# File 'app/models/mailer.rb', line 242

def wiki_content_updated(wiki_content)
  redmine_headers 'Project' => wiki_content.project.identifier,
                  'Wiki-Page-Id' => wiki_content.page.id
  @author = wiki_content.author
  message_id wiki_content
  recipients = wiki_content.notified_users
  cc = wiki_content.page.wiki.notified_watchers + wiki_content.page.notified_watchers - recipients
  @wiki_content = wiki_content
  @wiki_content_url = url_for(:controller => 'wiki', :action => 'show',
                                    :project_id => wiki_content.project,
                                    :id => wiki_content.page.title)
  @wiki_diff_url = url_for(:controller => 'wiki', :action => 'diff',
                                 :project_id => wiki_content.project, :id => wiki_content.page.title,
                                 :version => wiki_content.version)
  mail :to => recipients,
    :cc => cc,
    :subject => "[#{wiki_content.project.name}] #{l(:mail_subject_wiki_content_updated, :id => wiki_content.page.pretty_title)}"
end