jro_apps/redmine Commit - r528:7ca7e4bad503

Added mail notification when a new message is posted in the forums....

Jean-Philippe Lang -

r528:7ca7e4bad503

parent child

Context file:

r528:7ca7e4bad503

Collapse all files

app/models/message_observer.rb created 644 +24 0

@@ -0,0 +1,24
	1	# redMine - project management software
	2	# Copyright (C) 2006-2007 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	class MessageObserver < ActiveRecord::Observer
	19	def after_create(message)
	20	# send notification to board watchers
	21	recipients = message.board.watcher_recipients
	22	Mailer.deliver_message_posted(message, recipients) unless recipients.empty?
	23	end
	24	end

app/views/mailer/message_posted.rhtml created 644 +4 0

@@ -0,0 +1,4
	1	<%= l(:field_author) %>: <%= @message.author.name %>
	2	<%= url_for :only_path => false, :host => Setting.host_name, :controller => 'messages', :action => 'show', :board_id => @message.board_id, :id => @message.root %>
	3
	4	<%= @message.content %>

app/models/mailer.rb +8 0

             # 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 IssuesHelper
               def issue_add(issue)
                 set_language_if_valid(Setting.default_language)
                 # Sends to all project members
                 @recipients     = issue.project.members.collect { |m| m.user.mail if m.user.mail_notification }.compact
                 @from           = Setting.mail_from
                 @subject        = "[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}] #{issue.status.name} - #{issue.subject}"
                 @body['issue']  = issue
               end
               def issue_edit(journal)
                 set_language_if_valid(Setting.default_language)
                 # Sends to all project members
                 issue = journal.journalized
                 @recipients     = issue.project.members.collect { |m| m.user.mail if m.user.mail_notification }.compact
                 # Watchers in cc
                 @cc             = issue.watcher_recipients - @recipients
                 @from           = Setting.mail_from
                 @subject        = "[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}] #{issue.status.name} - #{issue.subject}"
                 @body['issue']  = issue
                 @body['journal']= journal
               end
               def document_add(document)
                 set_language_if_valid(Setting.default_language)
                 @recipients     = document.project.users.collect { |u| u.mail if u.mail_notification }.compact
                 @from           = Setting.mail_from
                 @subject        = "[#{document.project.name}] #{l(:label_document_new)}: #{document.title}"
                 @body['document'] = document
               end
               def attachments_add(attachments)
                 set_language_if_valid(Setting.default_language)
                 container = attachments.first.container
                 url = "http://#{Setting.host_name}/"
                 added_to = ""
                 case container.class.to_s
                 when 'Version'
                   url << "projects/list_files/#{container.project_id}"
                   added_to = "#{l(:label_version)}: #{container.name}"
                 when 'Document'
                   url << "documents/show/#{container.id}"
                   added_to = "#{l(:label_document)}: #{container.title}"
                 when 'Issue'
                   url << "issues/show/#{container.id}"
                   added_to = "#{container.tracker.name} ##{container.id}: #{container.subject}"
                 end
                 @recipients     = container.project.users.collect { |u| u.mail if u.mail_notification }.compact
                 @from           = Setting.mail_from
                 @subject        = "[#{container.project.name}] #{l(:label_attachment_new)}"
                 @body['attachments'] = attachments
                 @body['url']    = url
                 @body['added_to'] = added_to
               end
               def lost_password(token)
                 set_language_if_valid(token.user.language)
                 @recipients     = token.user.mail
                 @from           = Setting.mail_from
                 @subject        = l(:mail_subject_lost_password)
                 @body['token']  = token
               end
               def register(token)
                 set_language_if_valid(token.user.language)
                 @recipients     = token.user.mail
                 @from           = Setting.mail_from
                 @subject        = l(:mail_subject_register)
                 @body['token']  = token
               end
+              def message_posted(message, recipients)
+                set_language_if_valid(Setting.default_language)
+                @recipients     = recipients
+                @from           = Setting.mail_from
+                @subject        = "[#{message.board.project.name} - #{message.board.name}] #{message.subject}"
+                @body['message'] = message
+              end
             end

config/environment.rb +1 0

             # Be sure to restart your web server when you modify this file.
             # Uncomment below to force Rails into production mode when
             # you don't control web/app server and can't set it the proper way
             # ENV['RAILS_ENV'] ||= 'production'
             # Bootstrap the Rails environment, frameworks, and default configuration
             require File.join(File.dirname(__FILE__), 'boot')
             Rails::Initializer.run do |config|
               # Settings in config/environments/* take precedence those specified here
               # Skip frameworks you're not going to use
               # config.frameworks -= [ :action_web_service, :action_mailer ]
               # Add additional load paths for sweepers
               config.load_paths += %W( #{RAILS_ROOT}/app/sweepers )
               # Force all environments to use the same logger level
               # (by default production uses :info, the others :debug)
               # config.log_level = :debug
               # Use the database for sessions instead of the file system
               # (create the session table with 'rake create_sessions_table')
               # config.action_controller.session_store = :active_record_store
               # Enable page/fragment caching by setting a file-based store
               # (remember to create the caching directory and make it readable to the application)
               # config.action_controller.fragment_cache_store = :file_store, "#{RAILS_ROOT}/cache"
               # Activate observers that should always be running
               # config.active_record.observers = :cacher, :garbage_collector
+              config.active_record.observers = :message_observer
               # Make Active Record use UTC-base instead of local time
               # config.active_record.default_timezone = :utc
               # Use Active Record's schema dumper instead of SQL when creating the test database
               # (enables use of different database adapters for development and test environments)
               # config.active_record.schema_format = :ruby
               # See Rails::Configuration for more options
             	# SMTP server configuration
             	config.action_mailer.smtp_settings = {
             		:address => "127.0.0.1",
             		:port => 25,
             		:domain => "somenet.foo",
             		:authentication => :login,
             		:user_name => "redmine",
             		:password => "redmine",
             	}
             	config.action_mailer.perform_deliveries = true
             	# Tell ActionMailer not to deliver emails to the real world.
             	# The :test delivery method accumulates sent emails in the
             	# ActionMailer::Base.deliveries array.
             	#config.action_mailer.delivery_method = :test
             	config.action_mailer.delivery_method = :smtp
             end
             ActiveRecord::Errors.default_error_messages = {
               :inclusion => "activerecord_error_inclusion",
               :exclusion => "activerecord_error_exclusion",
               :invalid => "activerecord_error_invalid",
               :confirmation => "activerecord_error_confirmation",
               :accepted  => "activerecord_error_accepted",
               :empty => "activerecord_error_empty",
               :blank => "activerecord_error_blank",
               :too_long => "activerecord_error_too_long",
               :too_short => "activerecord_error_too_short",
               :wrong_length => "activerecord_error_wrong_length",
               :taken => "activerecord_error_taken",
               :not_a_number => "activerecord_error_not_a_number"
             }
             ActionView::Base.field_error_proc = Proc.new{ |html_tag, instance| "#{html_tag}" }
             GLoc.set_config :default_language => :en
             GLoc.clear_strings
             GLoc.set_kcode
             GLoc.load_localized_strings
             GLoc.set_config(:raise_string_not_found_errors => false)
             require 'redmine'

vendor/plugins/gloc-1.1.0/lib/gloc-rails.rb +2 -1

             # Copyright (c) 2005-2006 David Barri
             require 'gloc'
             module ActionController #:nodoc:
               class Base #:nodoc:
                 include GLoc
               end
               module Filters #:nodoc:
                 module ClassMethods
                   # This filter attempts to auto-detect the clients desired language.
                   # It first checks the params, then a cookie and then the HTTP_ACCEPT_LANGUAGE
                   # request header. If a language is found to match or be similar to a currently
                   # valid language, then it sets the current_language of the controller.
                   #
                   #   class ExampleController < ApplicationController
                   #     set_language :en
                   #     autodetect_language_filter :except => 'monkey', :on_no_lang => :lang_not_autodetected_callback
                   #     autodetect_language_filter :only => 'monkey', :check_cookie => 'monkey_lang', :check_accept_header => false
                   #     ...
                   #     def lang_not_autodetected_callback
                   #       redirect_to somewhere
                   #     end
                   #   end
                   #
                   # The <tt>args</tt> for this filter are exactly the same the arguments of
                   # <tt>before_filter</tt> with the following exceptions:
                   # * <tt>:check_params</tt> -- If false, then params will not be checked for a language.
                   #   If a String, then this will value will be used as the name of the param.
                   # * <tt>:check_cookie</tt> -- If false, then the cookie will not be checked for a language.
                   #   If a String, then this will value will be used as the name of the cookie.
                   # * <tt>:check_accept_header</tt> -- If false, then HTTP_ACCEPT_LANGUAGE will not be checked for a language.
                   # * <tt>:on_set_lang</tt> -- You can specify the name of a callback function to be called when the language
                   #   is successfully detected and set. The param must be a Symbol or a String which is the name of the function.
                   #   The callback function must accept one argument (the language) and must be instance level.
                   # * <tt>:on_no_lang</tt> -- You can specify the name of a callback function to be called when the language
                   #   couldn't be detected automatically. The param must be a Symbol or a String which is the name of the function.
                   #   The callback function must be instance level.
                   #
                   # You override the default names of the param or cookie by calling <tt>GLoc.set_config :default_param_name => 'new_param_name'</tt>
                   # and <tt>GLoc.set_config :default_cookie_name => 'new_cookie_name'</tt>.
                   def autodetect_language_filter(*args)
                     options= args.last.is_a?(Hash) ? args.last : {}
                     x= 'Proc.new { |c| l= nil;'
                     # :check_params
                     unless (v= options.delete(:check_params)) == false
                       name= v ? ":#{v}" : 'GLoc.get_config(:default_param_name)'
                       x << "l ||= GLoc.similar_language(c.params[#{name}]);"
                     end
                     # :check_cookie
                     unless (v= options.delete(:check_cookie)) == false
                       name= v ? ":#{v}" : 'GLoc.get_config(:default_cookie_name)'
                       x << "l ||= GLoc.similar_language(c.send(:cookies)[#{name}]);"
                     end
                     # :check_accept_header
                     unless options.delete(:check_accept_header) == false
                       x << %<
                           unless l
                             a= c.request.env['HTTP_ACCEPT_LANGUAGE'].split(/,|;/) rescue nil
                             a.each {|x| l ||= GLoc.similar_language(x)} if a
                           end; >
                     end
                     # Set language
                     x << 'ret= true;'
                     x << 'if l; c.set_language(l); c.headers[\'Content-Language\']= l.to_s; '
                     if options.has_key?(:on_set_lang)
                       x << "ret= c.#{options.delete(:on_set_lang)}(l);"
                     end
                     if options.has_key?(:on_no_lang)
                       x << "else; ret= c.#{options.delete(:on_no_lang)};"
                     end
                     x << 'end; ret }'
                     # Create filter
                     block= eval x
                     before_filter(*args, &block)
                   end
                 end
               end
             end
             # ==============================================================================
             module ActionMailer #:nodoc:
               # In addition to including GLoc, <tt>render_message</tt> is also overridden so
               # that mail templates contain the current language at the end of the file.
               # Eg. <tt>deliver_hello</tt> will render <tt>hello_en.rhtml</tt>.
               class Base
                 include GLoc
                 private
                 alias :render_message_without_gloc :render_message
                 def render_message(method_name, body)
-                  render_message_without_gloc("#{method_name}_#{current_language}", body)
+                  template = File.exist?("#{template_path}/#{method_name}_#{current_language}.rhtml") ? "#{method_name}_#{current_language}" : "#{method_name}"
+                  render_message_without_gloc(template, body)
                 end
               end
             end
             # ==============================================================================
             module ActionView #:nodoc:
               # <tt>initialize</tt> is overridden so that new instances of this class inherit
               # the current language of the controller.
               class Base
                 include GLoc
                 alias :initialize_without_gloc :initialize
                 def initialize(base_path = nil, assigns_for_first_render = {}, controller = nil)
                   initialize_without_gloc(base_path, assigns_for_first_render, controller)
                   set_language controller.current_language unless controller.nil?
                 end
               end
               module Helpers #:nodoc:
                 class InstanceTag
                   include GLoc
                   # Inherits the current language from the template object.
                   def current_language
                     @template_object.current_language
                   end
                 end
               end
             end
             # ==============================================================================
             module ActiveRecord #:nodoc:
               class Base #:nodoc:
                 include GLoc
               end
             #  class Errors
             #    include GLoc
             #    alias :add_without_gloc :add
             #    # The GLoc version of this method provides two extra features
             #    # * If <tt>msg</tt> is a string, it will be considered a GLoc string key.
             #    # * If <tt>msg</tt> is an array, the first element will be considered
             #    #   the string and the remaining elements will be considered arguments for the
             #    #   string. Eg. <tt>['Hi %s.','John']</tt>
             #    def add(attribute, msg= @@default_error_messages[:invalid])
             #      if msg.is_a?(Array)
             #        args= msg.clone
             #        msg= args.shift
             #        args= nil if args.empty?
             #      end
             #      msg= ltry(msg)
             #      msg= msg % args unless args.nil?
             #      add_without_gloc(attribute, msg)
             #    end
             #    # Inherits the current language from the base record.
             #    def current_language
             #      @base.current_language
             #    end
             #  end
               module Validations #:nodoc:
                 module ClassMethods
                   # The default Rails version of this function creates an error message and then
                   # passes it to ActiveRecord.Errors.
                   # The GLoc version of this method, sends an array to ActiveRecord.Errors that will
                   # be turned into a string by ActiveRecord.Errors which in turn allows for the message
                   # of this validation function to be a GLoc string key.
                   def validates_length_of(*attrs)
                     # Merge given options with defaults.
                     options = {
                       :too_long     => ActiveRecord::Errors.default_error_messages[:too_long],
                       :too_short    => ActiveRecord::Errors.default_error_messages[:too_short],
                       :wrong_length => ActiveRecord::Errors.default_error_messages[:wrong_length]
                     }.merge(DEFAULT_VALIDATION_OPTIONS)
                     options.update(attrs.pop.symbolize_keys) if attrs.last.is_a?(Hash)
                     # Ensure that one and only one range option is specified.
                     range_options = ALL_RANGE_OPTIONS & options.keys
                     case range_options.size
                       when 0
                         raise ArgumentError, 'Range unspecified.  Specify the :within, :maximum, :minimum, or :is option.'
                       when 1
                         # Valid number of options; do nothing.
                       else
                         raise ArgumentError, 'Too many range options specified.  Choose only one.'
                     end
                     # Get range option and value.
                     option = range_options.first
                     option_value = options[range_options.first]
                     case option
                     when :within, :in
                       raise ArgumentError, ":#{option} must be a Range" unless option_value.is_a?(Range)
                       too_short = [options[:too_short] , option_value.begin]
                       too_long  = [options[:too_long]  , option_value.end  ]
                       validates_each(attrs, options) do |record, attr, value|
                         if value.nil? or value.split(//).size < option_value.begin
                           record.errors.add(attr, too_short)
                         elsif value.split(//).size > option_value.end
                           record.errors.add(attr, too_long)
                         end
                       end
                     when :is, :minimum, :maximum
                       raise ArgumentError, ":#{option} must be a nonnegative Integer" unless option_value.is_a?(Integer) and option_value >= 0
                       # Declare different validations per option.
                       validity_checks = { :is => "==", :minimum => ">=", :maximum => "<=" }
                       message_options = { :is => :wrong_length, :minimum => :too_short, :maximum => :too_long }
                       message = [(options[:message] || options[message_options[option]]) , option_value]
                       validates_each(attrs, options) do |record, attr, value|
                         if value.kind_of?(String)
                           record.errors.add(attr, message) unless !value.nil? and value.split(//).size.method(validity_checks[option])[option_value]
                         else
                           record.errors.add(attr, message) unless !value.nil? and value.size.method(validity_checks[option])[option_value]
                         end
                       end
                     end
                   end
                   alias_method :validates_size_of, :validates_length_of
                 end
               end
             end
             # ==============================================================================
             module ApplicationHelper #:nodoc:
               include GLoc
             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