jro_apps/redmine Commit - r2458:4baf32b166a6

Fixing Plugin and Mailer default_url_options....

Eric Davis -

r2458:4baf32b166a6

parent child

Context file:

r2458:4baf32b166a6

Collapse all files

app/models/mailer.rb +6 -6

             # redMine - project management software
             # Copyright (C) 2006-2007  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 Mailer < ActionMailer::Base
               helper :application
               helper :issues
               helper :custom_fields
               include ActionController::UrlWriter
               include Redmine::I18n
+              def self.default_url_options
+                h = Setting.host_name
+                h = h.to_s.gsub(%r{\/.*$}, '') unless Redmine::Utils.relative_url_root.blank?
+                { :host => h, :protocol => Setting.protocol }
+              end
               def issue_add(issue)
                 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
                 recipients issue.recipients
                 cc(issue.watcher_recipients - @recipients)
                 subject "[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}] (#{issue.status.name}) #{issue.subject}"
                 body :issue => issue,
                      :issue_url => url_for(:controller => 'issues', :action => 'show', :id => issue)
               end
               def issue_edit(journal)
                 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
                 recipients issue.recipients
                 # Watchers in cc
                 cc(issue.watcher_recipients - @recipients)
                 s = "[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}] "
                 s << "(#{issue.status.name}) " if journal.new_value_for('status_id')
                 s << issue.subject
                 subject s
                 body :issue => issue,
                      :journal => journal,
                      :issue_url => url_for(:controller => 'issues', :action => 'show', :id => issue)
               end
               def reminder(user, issues, days)
                 set_language_if_valid user.language
                 recipients user.mail
                 subject l(:mail_subject_reminder, issues.size)
                 body :issues => issues,
                      :days => days,
                      :issues_url => url_for(:controller => 'issues', :action => 'index', :set_filter => 1, :assigned_to_id => user.id, :sort_key => 'due_date', :sort_order => 'asc')
               end
               def document_added(document)
                 redmine_headers 'Project' => document.project.identifier
                 recipients document.project.recipients
                 subject "[#{document.project.name}] #{l(:label_document_new)}: #{document.title}"
                 body :document => document,
                      :document_url => url_for(:controller => 'documents', :action => 'show', :id => document)
               end
               def attachments_added(attachments)
                 container = attachments.first.container
                 added_to = ''
                 added_to_url = ''
                 case container.class.name
                 when 'Project'
                   added_to_url = url_for(:controller => 'projects', :action => 'list_files', :id => container)
                   added_to = "#{l(:label_project)}: #{container}"
                 when 'Version'
                   added_to_url = url_for(:controller => 'projects', :action => 'list_files', :id => container.project_id)
                   added_to = "#{l(:label_version)}: #{container.name}"
                 when 'Document'
                   added_to_url = url_for(:controller => 'documents', :action => 'show', :id => container.id)
                   added_to = "#{l(:label_document)}: #{container.title}"
                 end
                 redmine_headers 'Project' => container.project.identifier
                 recipients container.project.recipients
                 subject "[#{container.project.name}] #{l(:label_attachment_new)}"
                 body :attachments => attachments,
                      :added_to => added_to,
                      :added_to_url => added_to_url
               end
               def news_added(news)
                 redmine_headers 'Project' => news.project.identifier
                 message_id news
                 recipients news.project.recipients
                 subject "[#{news.project.name}] #{l(:label_news)}: #{news.title}"
                 body :news => news,
                      :news_url => url_for(:controller => 'news', :action => 'show', :id => news)
               end
               def message_posted(message, recipients)
                 redmine_headers 'Project' => message.project.identifier,
                                 'Topic-Id' => (message.parent_id || message.id)
                 message_id message
                 references message.parent unless message.parent.nil?
                 recipients(recipients)
                 subject "[#{message.board.project.name} - #{message.board.name} - msg#{message.root.id}] #{message.subject}"
                 body :message => message,
                      :message_url => url_for(:controller => 'messages', :action => 'show', :board_id => message.board_id, :id => message.root)
               end
               def account_information(user, password)
                 set_language_if_valid user.language
                 recipients user.mail
                 subject l(:mail_subject_register, Setting.app_title)
                 body :user => user,
                      :password => password,
                      :login_url => url_for(:controller => 'account', :action => 'login')
               end
               def account_activation_request(user)
                 # Send the email to all active administrators
                 recipients User.active.find(:all, :conditions => {:admin => true}).collect { |u| u.mail }.compact
                 subject l(:mail_subject_account_activation_request, Setting.app_title)
                 body :user => user,
                      :url => url_for(:controller => 'users', :action => 'index', :status => User::STATUS_REGISTERED, :sort_key => 'created_on', :sort_order => 'desc')
               end
               # A registered user's account was activated by an administrator
               def account_activated(user)
                 set_language_if_valid user.language
                 recipients user.mail
                 subject l(:mail_subject_register, Setting.app_title)
                 body :user => user,
                      :login_url => url_for(:controller => 'account', :action => 'login')
               end
               def lost_password(token)
                 set_language_if_valid(token.user.language)
                 recipients token.user.mail
                 subject l(:mail_subject_lost_password, Setting.app_title)
                 body :token => token,
                      :url => url_for(:controller => 'account', :action => 'lost_password', :token => token.value)
               end
               def register(token)
                 set_language_if_valid(token.user.language)
                 recipients token.user.mail
                 subject l(:mail_subject_register, Setting.app_title)
                 body :token => token,
                      :url => url_for(:controller => 'account', :action => 'activate', :token => token.value)
               end
               def test(user)
                 set_language_if_valid(user.language)
                 recipients user.mail
                 subject 'Redmine test'
                 body :url => url_for(:controller => 'welcome')
               end
               # Overrides default deliver! method to prevent from sending an email
               # with no recipient, cc or bcc
               def deliver!(mail = @mail)
                 return false if (recipients.nil? || recipients.empty?) &&
                                 (cc.nil? || cc.empty?) &&
                                 (bcc.nil? || bcc.empty?)
                 # Set Message-Id and References
                 if @message_id_object
                   mail.message_id = self.class.message_id_for(@message_id_object)
                 end
                 if @references_objects
                   mail.references = @references_objects.collect {|o| self.class.message_id_for(o)}
                 end
                 super(mail)
               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)
               def self.reminders(options={})
                 days = options[:days] || 7
                 project = options[:project] ? Project.find(options[:project]) : nil
                 tracker = options[:tracker] ? Tracker.find(options[:tracker]) : nil
                 s = ARCondition.new ["#{IssueStatus.table_name}.is_closed = ? AND #{Issue.table_name}.due_date <= ?", false, days.day.from_now.to_date]
                 s << "#{Issue.table_name}.assigned_to_id IS NOT NULL"
                 s << "#{Project.table_name}.status = #{Project::STATUS_ACTIVE}"
                 s << "#{Issue.table_name}.project_id = #{project.id}" if project
                 s << "#{Issue.table_name}.tracker_id = #{tracker.id}" if tracker
                 issues_by_assignee = Issue.find(:all, :include => [:status, :assigned_to, :project, :tracker],
                                                       :conditions => s.conditions
                                                 ).group_by(&:assigned_to)
                 issues_by_assignee.each do |assignee, issues|
                   deliver_reminder(assignee, issues, days) unless assignee.nil?
                 end
               end
               private
               def initialize_defaults(method_name)
                 super
                 set_language_if_valid Setting.default_language
                 from Setting.mail_from
-                # URL options
-                h = Setting.host_name
-                h = h.to_s.gsub(%r{\/.*$}, '') unless Redmine::Utils.relative_url_root.blank?
-                default_url_options[:host] = h
-                default_url_options[:protocol] = Setting.protocol
                 # Common headers
                 headers 'X-Mailer' => 'Redmine',
                         'X-Redmine-Host' => Setting.host_name,
                         'X-Redmine-Site' => Setting.app_title
               end
               # Appends a Redmine header field (name is prepended with 'X-Redmine-')
               def redmine_headers(h)
                 h.each { |k,v| headers["X-Redmine-#{k}"] = v }
               end
               # Overrides the create_mail method
               def create_mail
                 # Removes the current user from the recipients and cc
                 # if he doesn't want to receive notifications about what he does
                 @author ||= User.current
                 if @author.pref[:no_self_notified]
                   recipients.delete(@author.mail) if recipients
                   cc.delete(@author.mail) if cc
                 end
                 # Blind carbon copy recipients
                 if Setting.bcc_recipients?
                   bcc([recipients, cc].flatten.compact.uniq)
                   recipients []
                   cc []
                 end
                 super
               end
               # Renders a message with the corresponding layout
               def render_message(method_name, body)
                 layout = method_name.to_s.match(%r{text\.html\.(rhtml|rxml)}) ? 'layout.text.html.rhtml' : 'layout.text.plain.rhtml'
                 body[:content_for_layout] = render(:file => method_name, :body => body)
                 ActionView::Base.new(template_root, body, self).render(:file => "mailer/#{layout}", :use_full_path => true)
               end
               # for the case of plain text only
               def body(*params)
                 value = super(*params)
                 if Setting.plain_text_mail?
                   templates = Dir.glob("#{template_path}/#{@template}.text.plain.{rhtml,erb}")
                   unless String === @body or templates.empty?
                     template = File.basename(templates.first)
                     @body[:content_for_layout] = render(:file => template, :body => @body)
                     @body = ActionView::Base.new(template_root, @body, self).render(:file => "mailer/layout.text.plain.rhtml", :use_full_path => true)
                     return @body
                   end
                 end
                 return value
               end
               # Makes partial rendering work with Rails 1.2 (retro-compatibility)
               def self.controller_path
                 ''
               end unless respond_to?('controller_path')
               # Returns a predictable Message-Id for the given object
               def self.message_id_for(object)
                 # id + timestamp should reduce the odds of a collision
                 # as far as we don't send multiple emails for the same object
                 hash = "redmine.#{object.class.name.demodulize.underscore}-#{object.id}.#{object.created_on.strftime("%Y%m%d%H%M%S")}"
                 host = Setting.mail_from.to_s.gsub(%r{^.*@}, '')
                 host = "#{::Socket.gethostname}.redmine" if host.empty?
                 "<#{hash}@#{host}>"
               end
               private
               def message_id(object)
                 @message_id_object = object
               end
               def references(object)
                 @references_objects ||= []
                 @references_objects << object
               end
             end
             # Patch TMail so that message_id is not overwritten
             module TMail
               class Mail
                 def add_message_id( fqdn = nil )
                   self.message_id ||= ::TMail::new_message_id(fqdn)
                 end
               end
             end

lib/redmine/hook.rb +8 -2

             # Redmine - project management software
             # Copyright (C) 2006-2008  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.
             module Redmine
               module Hook
                 include ActionController::UrlWriter
                 @@listener_classes = []
                 @@listeners = nil
                 @@hook_listeners = {}
                 class << self
                   # Adds a listener class.
                   # Automatically called when a class inherits from Redmine::Hook::Listener.
                   def add_listener(klass)
                     raise "Hooks must include Singleton module." unless klass.included_modules.include?(Singleton)
                     @@listener_classes << klass
                     clear_listeners_instances
                   end
                   # Returns all the listerners instances.
                   def listeners
                     @@listeners ||= @@listener_classes.collect {|listener| listener.instance}
                   end
                   # Returns the listeners instances for the given hook.
                   def hook_listeners(hook)
                     @@hook_listeners[hook] ||= listeners.select {|listener| listener.respond_to?(hook)}
                   end
                   # Clears all the listeners.
                   def clear_listeners
                     @@listener_classes = []
                     clear_listeners_instances
                   end
                   # Clears all the listeners instances.
                   def clear_listeners_instances
                     @@listeners = nil
                     @@hook_listeners = {}
                   end
                   # Calls a hook.
                   # Returns the listeners response.
                   def call_hook(hook, context={})
                     returning [] do |response|
                       hls = hook_listeners(hook)
                       if hls.any?
-                        default_url_options[:only_path] ||= true
                         hls.each {|listener| response << listener.send(hook, context)}
                       end
                     end
                   end
                 end
                 # Base class for hook listeners.
                 class Listener
                   include Singleton
                   include Redmine::I18n
                   # Registers the listener
                   def self.inherited(child)
                     Redmine::Hook.add_listener(child)
                     super
                   end
                 end
                 # Listener class used for views hooks.
                 # Listeners that inherit this class will include various helpers by default.
                 class ViewListener < Listener
                   include ERB::Util
                   include ActionView::Helpers::TagHelper
                   include ActionView::Helpers::FormHelper
                   include ActionView::Helpers::FormTagHelper
                   include ActionView::Helpers::FormOptionsHelper
                   include ActionView::Helpers::JavaScriptHelper
                   include ActionView::Helpers::PrototypeHelper
                   include ActionView::Helpers::NumberHelper
                   include ActionView::Helpers::UrlHelper
                   include ActionView::Helpers::AssetTagHelper
                   include ActionView::Helpers::TextHelper
                   include ActionController::UrlWriter
                   include ApplicationHelper
+                  # Default to creating links using only the path.  Subclasses can
+                  # change this default as needed
+                  def self.default_url_options
+                    {:only_path => true }
+                  end
                   # Helper method to directly render a partial using the context:
                   #
                   #   class MyHook < Redmine::Hook::ViewListener
                   #     render_on :view_issues_show_details_bottom, :partial => "show_more_data"
                   #   end
                   #
                   def self.render_on(hook, options={})
                     define_method hook do |context|
                       context[:controller].send(:render_to_string, {:locals => context}.merge(options))
                     end
                   end
                 end
                 # Helper module included in ApplicationHelper and ActionControllerso that
                 # hooks can be called in views like this:
                 #
                 #   <%= call_hook(:some_hook) %>
                 #   <%= call_hook(:another_hook, :foo => 'bar' %>
                 #
                 # Or in controllers like:
                 #   call_hook(:some_hook)
                 #   call_hook(:another_hook, :foo => 'bar'
                 #
                 # Hooks added to views will be concatenated into a string.  Hooks added to
                 # controllers will return an array of results.
                 #
                 # Several objects are automatically added to the call context:
                 #
                 # * project => current project
                 # * request => Request instance
                 # * controller => current Controller instance
                 #
                 module Helper
                   def call_hook(hook, context={})
                     if is_a?(ActionController::Base)
                       default_context = {:controller => self, :project => @project, :request => request}
                       Redmine::Hook.call_hook(hook, default_context.merge(context))
                     else
                       default_context = {:controller => controller, :project => @project, :request => request}
                       Redmine::Hook.call_hook(hook, default_context.merge(context)).join(' ')
                     end
                   end
                 end
               end
             end
             ApplicationHelper.send(:include, Redmine::Hook::Helper)
             ActionController::Base.send(:include, Redmine::Hook::Helper)

test/unit/lib/redmine/hook_test.rb +19 -1

             # redMine - project management software
             # Copyright (C) 2006-2008  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 File.dirname(__FILE__) + '/../../../test_helper'
             class Redmine::Hook::ManagerTest < Test::Unit::TestCase
+              fixtures :issues
               # Some hooks that are manually registered in these tests
               class TestHook < Redmine::Hook::ViewListener; end
               class TestHook1 < TestHook
                 def view_layouts_base_html_head(context)
                   'Test hook 1 listener.'
                 end
               end
               class TestHook2 < TestHook
                 def view_layouts_base_html_head(context)
                   'Test hook 2 listener.'
                 end
               end
               class TestHook3 < TestHook
                 def view_layouts_base_html_head(context)
                   "Context keys: #{context.keys.collect(&:to_s).sort.join(', ')}."
                 end
               end
               class TestLinkToHook < TestHook
                 def view_layouts_base_html_head(context)
                   link_to('Issues', :controller => 'issues')
                 end
               end
               class TestHookHelperController < ActionController::Base
                 include Redmine::Hook::Helper
               end
               class TestHookHelperView < ActionView::Base
                 include Redmine::Hook::Helper
               end
               Redmine::Hook.clear_listeners
               def setup
                 @hook_module = Redmine::Hook
                 @hook_helper = TestHookHelperController.new
                 @view_hook_helper = TestHookHelperView.new(RAILS_ROOT + '/app/views')
               end
               def teardown
                 @hook_module.clear_listeners
-                @hook_module.default_url_options = { }
               end
               def test_clear_listeners
                 assert_equal 0, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                 @hook_module.add_listener(TestHook1)
                 @hook_module.add_listener(TestHook2)
                 assert_equal 2, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                 @hook_module.clear_listeners
                 assert_equal 0, @hook_module.hook_listeners(:view_layouts_base_html_head).size
               end
               def test_add_listener
                 assert_equal 0, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                 @hook_module.add_listener(TestHook1)
                 assert_equal 1, @hook_module.hook_listeners(:view_layouts_base_html_head).size
               end
               def test_call_hook
                 @hook_module.add_listener(TestHook1)
                 assert_equal ['Test hook 1 listener.'], @hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_with_context
                 @hook_module.add_listener(TestHook3)
                 assert_equal ['Context keys: bar, controller, foo, project, request.'],
                              @hook_helper.call_hook(:view_layouts_base_html_head, :foo => 1, :bar => 'a')
               end
               def test_call_hook_with_multiple_listeners
                 @hook_module.add_listener(TestHook1)
                 @hook_module.add_listener(TestHook2)
                 assert_equal ['Test hook 1 listener.', 'Test hook 2 listener.'], @hook_helper.call_hook(:view_layouts_base_html_head)
               end
               # Context: Redmine::Hook::Helper.call_hook default_url
               def test_call_hook_default_url_options
                 @hook_module.add_listener(TestLinkToHook)
                 assert_equal ['<a href="/issues">Issues</a>'], @hook_helper.call_hook(:view_layouts_base_html_head)
               end
               # Context: Redmine::Hook::Helper.call_hook
               def test_call_hook_with_project_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /project/i, @hook_helper.call_hook(:view_layouts_base_html_head)[0]
               end
               def test_call_hook_from_controller_with_controller_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /controller/i, @hook_helper.call_hook(:view_layouts_base_html_head)[0]
               end
               def test_call_hook_from_controller_with_request_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /request/i, @hook_helper.call_hook(:view_layouts_base_html_head)[0]
               end
               def test_call_hook_from_view_with_project_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /project/i, @view_hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_from_view_with_controller_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /controller/i, @view_hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_from_view_with_request_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /request/i, @view_hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_from_view_should_join_responses_with_a_space
                 @hook_module.add_listener(TestHook1)
                 @hook_module.add_listener(TestHook2)
                 assert_equal 'Test hook 1 listener. Test hook 2 listener.',
                              @view_hook_helper.call_hook(:view_layouts_base_html_head)
               end
+              def test_call_hook_should_not_change_the_default_url_for_email_notifications
+                issue = Issue.find(1)
+                ActionMailer::Base.deliveries.clear
+                Mailer.deliver_issue_add(issue)
+                mail = ActionMailer::Base.deliveries.last
+                @hook_module.add_listener(TestLinkToHook)
+                @hook_helper.call_hook(:view_layouts_base_html_head)
+                ActionMailer::Base.deliveries.clear
+                Mailer.deliver_issue_add(issue)
+                mail2 = ActionMailer::Base.deliveries.last
+                assert_equal mail.body, mail2.body
+               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