jro_apps/redmine Commit - r14885:a47eab886835

Let the mailer set the email content (#21421)....

Jean-Philippe Lang -

r14885:a47eab886835

parent child

Context file:

r14885:a47eab886835

Collapse all files

app/controllers/account_controller.rb +1 -6

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              class AccountController < ApplicationController
                helper :custom_fields
                include CustomFieldsHelper
                # prevents login action to be filtered by check_if_login_required application scope filter
                skip_before_filter :check_if_login_required, :check_password_change
                # Overrides ApplicationController#verify_authenticity_token to disable
                # token verification on openid callbacks
                def verify_authenticity_token
                  unless using_open_id?
                    super
                  end
                end
                # Login request and validation
                def login
                  if request.get?
                    if User.current.logged?
                      redirect_back_or_default home_url, :referer => true
                    end
                  else
                    authenticate_user
                  end
                rescue AuthSourceException => e
                  logger.error "An error occured when authenticating #{params[:username]}: #{e.message}"
                  render_error :message => e.message
                end
                # Log out current user and redirect to welcome page
                def logout
                  if User.current.anonymous?
                    redirect_to home_url
                  elsif request.post?
                    logout_user
                    redirect_to home_url
                  end
                  # display the logout form
                end
                # Lets user choose a new password
                def lost_password
                  (redirect_to(home_url); return) unless Setting.lost_password?
                  if params[:token]
                    @token = Token.find_token("recovery", params[:token].to_s)
                    if @token.nil? || @token.expired?
                      redirect_to home_url
                      return
                    end
                    @user = @token.user
                    unless @user && @user.active?
                      redirect_to home_url
                      return
                    end
                    if request.post?
                      @user.password, @user.password_confirmation = params[:new_password], params[:new_password_confirmation]
                      if @user.save
                        @token.destroy
-                       Mailer.security_notification(@user,
-                         message: :mail_body_security_notification_change,
-                         field: :field_password,
-                         title: :button_change_password,
-                         url: {controller: 'my', action: 'password'}
-                       ).deliver
+                       Mailer.password_updated(@user)
                        flash[:notice] = l(:notice_account_password_updated)
                        redirect_to signin_path
                        return
                      end
                    end
                    render :template => "account/password_recovery"
                    return
                  else
                    if request.post?
                      email = params[:mail].to_s
                      user = User.find_by_mail(email)
                      # user not found
                      unless user
                        flash.now[:error] = l(:notice_account_unknown_email)
                        return
                      end
                      unless user.active?
                        handle_inactive_user(user, lost_password_path)
                        return
                      end
                      # user cannot change its password
                      unless user.change_password_allowed?
                        flash.now[:error] = l(:notice_can_t_change_password)
                        return
                      end
                      # create a new token for password recovery
                      token = Token.new(:user => user, :action => "recovery")
                      if token.save
                        # Don't use the param to send the email
                        recipent = user.mails.detect {|e| email.casecmp(e) == 0} || user.mail
                        Mailer.lost_password(token, recipent).deliver
                        flash[:notice] = l(:notice_account_lost_email_sent)
                        redirect_to signin_path
                        return
                      end
                    end
                  end
                end
                # User self-registration
                def register
                  (redirect_to(home_url); return) unless Setting.self_registration? || session[:auth_source_registration]
                  if request.get?
                    session[:auth_source_registration] = nil
                    @user = User.new(:language => current_language.to_s)
                  else
                    user_params = params[:user] || {}
                    @user = User.new
                    @user.safe_attributes = user_params
                    @user.pref.attributes = params[:pref] if params[:pref]
                    @user.admin = false
                    @user.register
                    if session[:auth_source_registration]
                      @user.activate
                      @user.login = session[:auth_source_registration][:login]
                      @user.auth_source_id = session[:auth_source_registration][:auth_source_id]
                      if @user.save
                        session[:auth_source_registration] = nil
                        self.logged_user = @user
                        flash[:notice] = l(:notice_account_activated)
                        redirect_to my_account_path
                      end
                    else
                      @user.login = params[:user][:login]
                      unless user_params[:identity_url].present? && user_params[:password].blank? && user_params[:password_confirmation].blank?
                        @user.password, @user.password_confirmation = user_params[:password], user_params[:password_confirmation]
                      end
                      case Setting.self_registration
                      when '1'
                        register_by_email_activation(@user)
                      when '3'
                        register_automatically(@user)
                      else
                        register_manually_by_administrator(@user)
                      end
                    end
                  end
                end
                # Token based account activation
                def activate
                  (redirect_to(home_url); return) unless Setting.self_registration? && params[:token].present?
                  token = Token.find_token('register', params[:token].to_s)
                  (redirect_to(home_url); return) unless token and !token.expired?
                  user = token.user
                  (redirect_to(home_url); return) unless user.registered?
                  user.activate
                  if user.save
                    token.destroy
                    flash[:notice] = l(:notice_account_activated)
                  end
                  redirect_to signin_path
                end
                # Sends a new account activation email
                def activation_email
                  if session[:registered_user_id] && Setting.self_registration == '1'
                    user_id = session.delete(:registered_user_id).to_i
                    user = User.find_by_id(user_id)
                    if user && user.registered?
                      register_by_email_activation(user)
                      return
                    end
                  end
                  redirect_to(home_url)
                end
                private
                def authenticate_user
                  if Setting.openid? && using_open_id?
                    open_id_authenticate(params[:openid_url])
                  else
                    password_authentication
                  end
                end
                def password_authentication
                  user = User.try_to_login(params[:username], params[:password], false)
                  if user.nil?
                    invalid_credentials
                  elsif user.new_record?
                    onthefly_creation_failed(user, {:login => user.login, :auth_source_id => user.auth_source_id })
                  else
                    # Valid user
                    if user.active?
                      successful_authentication(user)
                      update_sudo_timestamp! # activate Sudo Mode
                    else
                      handle_inactive_user(user)
                    end
                  end
                end
                def open_id_authenticate(openid_url)
                  back_url = signin_url(:autologin => params[:autologin])
                  authenticate_with_open_id(
                        openid_url, :required => [:nickname, :fullname, :email],
                        :return_to => back_url, :method => :post
                  ) do |result, identity_url, registration|
                    if result.successful?
                      user = User.find_or_initialize_by_identity_url(identity_url)
                      if user.new_record?
                        # Self-registration off
                        (redirect_to(home_url); return) unless Setting.self_registration?
                        # Create on the fly
                        user.login = registration['nickname'] unless registration['nickname'].nil?
                        user.mail = registration['email'] unless registration['email'].nil?
                        user.firstname, user.lastname = registration['fullname'].split(' ') unless registration['fullname'].nil?
                        user.random_password
                        user.register
                        case Setting.self_registration
                        when '1'
                          register_by_email_activation(user) do
                            onthefly_creation_failed(user)
                          end
                        when '3'
                          register_automatically(user) do
                            onthefly_creation_failed(user)
                          end
                        else
                          register_manually_by_administrator(user) do
                            onthefly_creation_failed(user)
                          end
                        end
                      else
                        # Existing record
                        if user.active?
                          successful_authentication(user)
                        else
                          handle_inactive_user(user)
                        end
                      end
                    end
                  end
                end
                def successful_authentication(user)
                  logger.info "Successful authentication for '#{user.login}' from #{request.remote_ip} at #{Time.now.utc}"
                  # Valid user
                  self.logged_user = user
                  # generate a key and set cookie if autologin
                  if params[:autologin] && Setting.autologin?
                    set_autologin_cookie(user)
                  end
                  call_hook(:controller_account_success_authentication_after, {:user => user })
                  redirect_back_or_default my_page_path
                end
                def set_autologin_cookie(user)
                  token = Token.create(:user => user, :action => 'autologin')
                  secure = Redmine::Configuration['autologin_cookie_secure']
                  if secure.nil?
                    secure = request.ssl?
                  end
                  cookie_options = {
                    :value => token.value,
                    :expires => 1.year.from_now,
                    :path => (Redmine::Configuration['autologin_cookie_path'] || RedmineApp::Application.config.relative_url_root || '/'),
                    :secure => secure,
                    :httponly => true
                  }
                  cookies[autologin_cookie_name] = cookie_options
                end
                # Onthefly creation failed, display the registration form to fill/fix attributes
                def onthefly_creation_failed(user, auth_source_options = { })
                  @user = user
                  session[:auth_source_registration] = auth_source_options unless auth_source_options.empty?
                  render :action => 'register'
                end
                def invalid_credentials
                  logger.warn "Failed login for '#{params[:username]}' from #{request.remote_ip} at #{Time.now.utc}"
                  flash.now[:error] = l(:notice_account_invalid_credentials)
                end
                # Register a user for email activation.
                #
                # Pass a block for behavior when a user fails to save
                def register_by_email_activation(user, &block)
                  token = Token.new(:user => user, :action => "register")
                  if user.save and token.save
                    Mailer.register(token).deliver
                    flash[:notice] = l(:notice_account_register_done, :email => ERB::Util.h(user.mail))
                    redirect_to signin_path
                  else
                    yield if block_given?
                  end
                end
                # Automatically register a user
                #
                # Pass a block for behavior when a user fails to save
                def register_automatically(user, &block)
                  # Automatic activation
                  user.activate
                  user.last_login_on = Time.now
                  if user.save
                    self.logged_user = user
                    flash[:notice] = l(:notice_account_activated)
                    redirect_to my_account_path
                  else
                    yield if block_given?
                  end
                end
                # Manual activation by the administrator
                #
                # Pass a block for behavior when a user fails to save
                def register_manually_by_administrator(user, &block)
                  if user.save
                    # Sends an email to the administrators
                    Mailer.account_activation_request(user).deliver
                    account_pending(user)
                  else
                    yield if block_given?
                  end
                end
                def handle_inactive_user(user, redirect_path=signin_path)
                  if user.registered?
                    account_pending(user, redirect_path)
                  else
                    account_locked(user, redirect_path)
                  end
                end
                def account_pending(user, redirect_path=signin_path)
                  if Setting.self_registration == '1'
                    flash[:error] = l(:notice_account_not_activated_yet, :url => activation_email_path)
                    session[:registered_user_id] = user.id
                  else
                    flash[:error] = l(:notice_account_pending)
                  end
                  redirect_to redirect_path
                end
                def account_locked(user, redirect_path=signin_path)
                  flash[:error] = l(:notice_account_locked)
                  redirect_to redirect_path
                end
              end

app/controllers/my_controller.rb +1 -6

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              class MyController < ApplicationController
                before_filter :require_login
                # let user change user's password when user has to
                skip_before_filter :check_password_change, :only => :password
                require_sudo_mode :account, only: :post
                require_sudo_mode :reset_rss_key, :reset_api_key, :show_api_key, :destroy
                helper :issues
                helper :users
                helper :custom_fields
                BLOCKS = { 'issuesassignedtome' => :label_assigned_to_me_issues,
                           'issuesreportedbyme' => :label_reported_issues,
                           'issueswatched' => :label_watched_issues,
                           'news' => :label_news_latest,
                           'calendar' => :label_calendar,
                           'documents' => :label_document_plural,
                           'timelog' => :label_spent_time
                         }.merge(Redmine::Views::MyPage::Block.additional_blocks).freeze
                DEFAULT_LAYOUT = {  'left' => ['issuesassignedtome'],
                                    'right' => ['issuesreportedbyme']
                                 }.freeze
                def index
                  page
                  render :action => 'page'
                end
                # Show user's page
                def page
                  @user = User.current
                  @blocks = @user.pref[:my_page_layout] || DEFAULT_LAYOUT
                end
                # Edit user's account
                def account
                  @user = User.current
                  @pref = @user.pref
                  if request.post?
                    @user.safe_attributes = params[:user] if params[:user]
                    @user.pref.attributes = params[:pref] if params[:pref]
                    if @user.save
                      @user.pref.save
                      set_language_if_valid @user.language
                      flash[:notice] = l(:notice_account_updated)
                      redirect_to my_account_path
                      return
                    end
                  end
                end
                # Destroys user's account
                def destroy
                  @user = User.current
                  unless @user.own_account_deletable?
                    redirect_to my_account_path
                    return
                  end
                  if request.post? && params[:confirm]
                    @user.destroy
                    if @user.destroyed?
                      logout_user
                      flash[:notice] = l(:notice_account_deleted)
                    end
                    redirect_to home_path
                  end
                end
                # Manage user's password
                def password
                  @user = User.current
                  unless @user.change_password_allowed?
                    flash[:error] = l(:notice_can_t_change_password)
                    redirect_to my_account_path
                    return
                  end
                  if request.post?
                    if !@user.check_password?(params[:password])
                      flash.now[:error] = l(:notice_account_wrong_password)
                    elsif params[:password] == params[:new_password]
                      flash.now[:error] = l(:notice_new_password_must_be_different)
                    else
                      @user.password, @user.password_confirmation = params[:new_password], params[:new_password_confirmation]
                      @user.must_change_passwd = false
                      if @user.save
                        # The session token was destroyed by the password change, generate a new one
                        session[:tk] = @user.generate_session_token
-                       Mailer.security_notification(@user,
-                         message: :mail_body_security_notification_change,
-                         field: :field_password,
-                         title: :button_change_password,
-                         url: {controller: 'my', action: 'password'}
-                       ).deliver
+                       Mailer.password_updated(@user)
                        flash[:notice] = l(:notice_account_password_updated)
                        redirect_to my_account_path
                      end
                    end
                  end
                end
                # Create a new feeds key
                def reset_rss_key
                  if request.post?
                    if User.current.rss_token
                      User.current.rss_token.destroy
                      User.current.reload
                    end
                    User.current.rss_key
                    flash[:notice] = l(:notice_feeds_access_key_reseted)
                  end
                  redirect_to my_account_path
                end
                def show_api_key
                  @user = User.current
                end
                # Create a new API key
                def reset_api_key
                  if request.post?
                    if User.current.api_token
                      User.current.api_token.destroy
                      User.current.reload
                    end
                    User.current.api_key
                    flash[:notice] = l(:notice_api_access_key_reseted)
                  end
                  redirect_to my_account_path
                end
                # User's page layout configuration
                def page_layout
                  @user = User.current
                  @blocks = @user.pref[:my_page_layout] || DEFAULT_LAYOUT.dup
                  @block_options = []
                  BLOCKS.each do |k, v|
                    unless @blocks.values.flatten.include?(k)
                      @block_options << [l("my.blocks.#{v}", :default => [v, v.to_s.humanize]), k.dasherize]
                    end
                  end
                end
                # Add a block to user's page
                # The block is added on top of the page
                # params[:block] : id of the block to add
                def add_block
                  block = params[:block].to_s.underscore
                  if block.present? && BLOCKS.key?(block)
                    @user = User.current
                    layout = @user.pref[:my_page_layout] || {}
                    # remove if already present in a group
                    %w(top left right).each {|f| (layout[f] ||= []).delete block }
                    # add it on top
                    layout['top'].unshift block
                    @user.pref[:my_page_layout] = layout
                    @user.pref.save
                  end
                  redirect_to my_page_layout_path
                end
                # Remove a block to user's page
                # params[:block] : id of the block to remove
                def remove_block
                  block = params[:block].to_s.underscore
                  @user = User.current
                  # remove block in all groups
                  layout = @user.pref[:my_page_layout] || {}
                  %w(top left right).each {|f| (layout[f] ||= []).delete block }
                  @user.pref[:my_page_layout] = layout
                  @user.pref.save
                  redirect_to my_page_layout_path
                end
                # Change blocks order on user's page
                # params[:group] : group to order (top, left or right)
                # params[:list-(top|left|right)] : array of block ids of the group
                def order_blocks
                  group = params[:group]
                  @user = User.current
                  if group.is_a?(String)
                    group_items = (params["blocks"] || []).collect(&:underscore)
                    group_items.each {|s| s.sub!(/^block_/, '')}
                    if group_items and group_items.is_a? Array
                      layout = @user.pref[:my_page_layout] || {}
                      # remove group blocks if they are presents in other groups
                      %w(top left right).each {|f|
                        layout[f] = (layout[f] || []) - group_items
                      }
                      layout[group] = group_items
                      @user.pref[:my_page_layout] = layout
                      @user.pref.save
                    end
                  end
                  render :nothing => true
                end
              end

app/models/mailer.rb +10 0

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require 'roadie'
              class Mailer < ActionMailer::Base
                layout 'mailer'
                helper :application
                helper :issues
                helper :custom_fields
                include Redmine::I18n
                include Roadie::Rails::Automatic
                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
                # Builds a mail for notifying to_users and cc_users about a new issue
                def issue_add(issue, to_users, cc_users)
                  redmine_headers 'Project' => issue.project.identifier,
                                  'Issue-Id' => issue.id,
                                  'Issue-Author' => issue.author.login
                  redmine_headers 'Issue-Assignee' => issue.assigned_to.login 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
                # Notifies users about a new issue
                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
                # Builds a mail for notifying to_users and cc_users about an issue update
                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.login
                  redmine_headers 'Issue-Assignee' => issue.assigned_to.login 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
                # Notifies users about an issue update
                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
                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
                # 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
                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
                # 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
                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
                # 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
                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
                # 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
                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
                # 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
                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
                # 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
                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
                # 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
                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
                # 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
                def account_information(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
                # 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
                def account_activation_request(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
                # 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
                def account_activated(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
                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
+               # Notifies user that his password was updated
+               def self.password_updated(user)
+                 Mailer.security_notification(user,
+                   message: :mail_body_security_notification_change,
+                   field: :field_password,
+                   title: :button_change_password,
+                   url: {controller: 'my', action: 'password'}
+                 ).deliver
+               end
                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
                def security_notification(recipients, options={})
                  redmine_headers 'Sender' => User.current.login
                  @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 => l(:mail_subject_security_notification)
                end
                def settings_updated(recipients, changes)
                  redmine_headers 'Sender' => User.current.login
                  @changes = changes
                  @url = url_for(controller: 'settings', action: 'index')
                  mail :to => recipients,
                    :subject => l(:mail_subject_security_notification)
                end
              	# Notifies admins about settings changes
                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
                def test_email(user)
                  set_language_if_valid(user.language)
                  @url = url_for(:controller => 'welcome')
                  mail :to => user.mail,
                    :subject => 'Redmine test'
                end
                # 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)
                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
                # Activates/desactivates email deliveries during +block+
                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
                # Sends emails synchronously in the given block
                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
                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.login
                  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
                def initialize(*args)
                  @initial_language = current_language
                  set_language_if_valid Setting.default_language
                  super
                end
                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
                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
                # 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"]
                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
                private
                # Appends a Redmine header field (name is prepended with 'X-Redmine-')
                def redmine_headers(h)
                  h.each { |k,v| headers["X-Redmine-#{k}"] = v.to_s }
                end
                def self.token_for(object, rand=true)
                  timestamp = object.send(object.respond_to?(:created_on) ? :created_on : :updated_on)
                  hash = [
                    "redmine",
                    "#{object.class.name.demodulize.underscore}-#{object.id}",
                    timestamp.strftime("%Y%m%d%H%M%S")
                  ]
                  if rand
                    hash << Redmine::Utils.random_hex(8)
                  end
                  host = Setting.mail_from.to_s.strip.gsub(%r{^.*@|>}, '')
                  host = "#{::Socket.gethostname}.redmine" if host.empty?
                  "#{hash.join('.')}@#{host}"
                end
                # Returns a Message-Id for the given object
                def self.message_id_for(object)
                  token_for(object, true)
                end
                # Returns a uniq token for a given object referenced by all notifications
                # related to this object
                def self.references_for(object)
                  token_for(object, false)
                end
                def message_id(object)
                  @message_id_object = object
                end
                def references(object)
                  @references_objects ||= []
                  @references_objects << object
                end
                def mylogger
                  Rails.logger
                end
              end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages