jro_apps/redmine Commit - r4109:437690119b0b

Allow admins to edit user's email notifications and preferences. #3503...

Eric Davis -

r4109:437690119b0b

parent child

Context file:

r4109:437690119b0b

Collapse all files

app/views/users/_mail_notifications.html.erb created 644 +12 0

@@ -0,0 +1,12
	1	<p>
	2	<%= select_tag 'notification_option', options_for_select(@notification_options.collect {\|o\| [l(o.last), o.first]}, @notification_option.to_sym),
	3	:onchange => 'if ($("notification_option").value == "selected") {Element.show("notified-projects")} else {Element.hide("notified-projects")}' %>
	4	</p>
	5	<% content_tag 'div', :id => 'notified-projects', :style => (@notification_option == 'selected' ? '' : 'display:none;') do %>
	6	<p><% @user.projects.each do \|project\| %>
	7	<label><%= check_box_tag 'notified_project_ids[]', project.id, @user.notified_projects_ids.include?(project.id) %> <%=h project.name %></label><br />
	8	<% end %></p>
	9	<p><em><%= l(:text_user_mail_option) %></em></p>
	10	<% end %>
	11	<p><label><%= l(:label_user_mail_no_self_notified) %></label><%= check_box_tag 'no_self_notified', 1, @user.pref[:no_self_notified] %></p>
	12

app/views/users/_preferences.html.erb created 644 +6 0

@@ -0,0 +1,6
	1	<% fields_for :pref, @user.pref, :builder => TabularFormBuilder, :lang => current_language do \|pref_fields\| %>
	2	<p><%= pref_fields.check_box :hide_mail %></p>
	3	<p><%= pref_fields.select :time_zone, ActiveSupport::TimeZone.all.collect {\|z\| [ z.to_s, z.name ]}, :include_blank => true %></p>
	4	<p><%= pref_fields.select :comments_sorting, [[l(:label_chronological_order), 'asc'], [l(:label_reverse_chronological_order), 'desc']] %></p>
	5	<% end %>
	6

app/controllers/users_controller.rb +43 0

             # Redmine - project management software
             # Copyright (C) 2006-2009  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 UsersController < ApplicationController
               layout 'admin'
               before_filter :require_admin, :except => :show
               helper :sort
               include SortHelper
               helper :custom_fields
               include CustomFieldsHelper
               def index
                 sort_init 'login', 'asc'
                 sort_update %w(login firstname lastname mail admin created_on last_login_on)
                 @status = params[:status] ? params[:status].to_i : 1
                 c = ARCondition.new(@status == 0 ? "status <> 0" : ["status = ?", @status])
                 unless params[:name].blank?
                   name = "%#{params[:name].strip.downcase}%"
                   c << ["LOWER(login) LIKE ? OR LOWER(firstname) LIKE ? OR LOWER(lastname) LIKE ? OR LOWER(mail) LIKE ?", name, name, name, name]
                 end
                 @user_count = User.count(:conditions => c.conditions)
                 @user_pages = Paginator.new self, @user_count,
             								per_page_option,
             								params['page']
                 @users =  User.find :all,:order => sort_clause,
                                     :conditions => c.conditions,
             						:limit  =>  @user_pages.items_per_page,
             						:offset =>  @user_pages.current.offset
                 render :layout => !request.xhr?
               end
               def show
                 @user = User.find(params[:id])
                 @custom_values = @user.custom_values
                 # show projects based on current user visibility
                 @memberships = @user.memberships.all(:conditions => Project.visible_by(User.current))
                 events = Redmine::Activity::Fetcher.new(User.current, :author => @user).events(nil, nil, :limit => 10)
                 @events_by_day = events.group_by(&:event_date)
                 unless User.current.admin?
                   if !@user.active? || (@user != User.current  && @memberships.empty? && events.empty?)
                     render_404
                     return
                   end
                 end
                 render :layout => 'base'
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def add
+                @notification_options = User::MAIL_NOTIFICATION_OPTIONS
+                @notification_option = Setting.default_notification_option
                 @user = User.new(:language => Setting.default_language)
                 @auth_sources = AuthSource.find(:all)
+                # TODO: Similar to My#account
+                # Only users that belong to more than 1 project can select projects for which they are notified
+                # Note that @user.membership.size would fail since AR ignores
+                # :include association option when doing a count
+                if @user.memberships.length < 1
+                  @notification_options.delete_if {|option| option.first == :selected}
+                end
               end
               verify :method => :post, :only => :create, :render => {:nothing => true, :status => :method_not_allowed }
               def create
+                @notification_options = User::MAIL_NOTIFICATION_OPTIONS
+                @notification_option = Setting.default_notification_option
                 @user = User.new(params[:user])
                 @user.admin = params[:user][:admin] || false
                 @user.login = params[:user][:login]
                 @user.password, @user.password_confirmation = params[:password], params[:password_confirmation] unless @user.auth_source_id
+                # TODO: Similar to My#account
+                @user.mail_notification = params[:notification_option] || 'only_my_events'
+                @user.pref.attributes = params[:pref]
+                @user.pref[:no_self_notified] = (params[:no_self_notified] == '1')
                 if @user.save
+                  @user.pref.save
+                  @user.notified_project_ids = (params[:notification_option] == 'selected' ? params[:notified_project_ids] : [])
                   Mailer.deliver_account_information(@user, params[:password]) if params[:send_information]
                   flash[:notice] = l(:notice_successful_create)
                   redirect_to(params[:continue] ? {:controller => 'users', :action => 'add'} :
                                                   {:controller => 'users', :action => 'edit', :id => @user})
                   return
                 else
                   @auth_sources = AuthSource.find(:all)
+                  @notification_option = @user.mail_notification
                   render :action => 'add'
                 end
               end
               def edit
                 @user = User.find(params[:id])
+                # TODO: Similar to My#account
+                @notification_options = User::MAIL_NOTIFICATION_OPTIONS
+                # Only users that belong to more than 1 project can select projects for which they are notified
+                # Note that @user.membership.size would fail since AR ignores
+                # :include association option when doing a count
+                if @user.memberships.length < 1
+                  @notification_options.delete_if {|option| option.first == :selected}
+                end
+                @notification_option = @user.mail_notification
                 if request.post?
                   @user.admin = params[:user][:admin] if params[:user][:admin]
                   @user.login = params[:user][:login] if params[:user][:login]
                   if params[:password].present? && (@user.auth_source_id.nil? || params[:user][:auth_source_id].blank?)
                     @user.password, @user.password_confirmation = params[:password], params[:password_confirmation]
                   end
                   @user.group_ids = params[:user][:group_ids] if params[:user][:group_ids]
                   @user.attributes = params[:user]
                   # Was the account actived ? (do it before User#save clears the change)
                   was_activated = (@user.status_change == [User::STATUS_REGISTERED, User::STATUS_ACTIVE])
+                  # TODO: Similar to My#account
+                  @user.mail_notification = params[:notification_option] || 'only_my_events'
+                  @user.pref.attributes = params[:pref]
+                  @user.pref[:no_self_notified] = (params[:no_self_notified] == '1')
                   if @user.save
+                    @user.pref.save
+                    @user.notified_project_ids = (params[:notification_option] == 'selected' ? params[:notified_project_ids] : [])
                     if was_activated
                       Mailer.deliver_account_activated(@user)
                     elsif @user.active? && params[:send_information] && !params[:password].blank? && @user.auth_source_id.nil?
                       Mailer.deliver_account_information(@user, params[:password])
                     end
                     flash[:notice] = l(:notice_successful_update)
                     redirect_to :back
                   end
                 end
                 @auth_sources = AuthSource.find(:all)
                 @membership ||= Member.new
               rescue ::ActionController::RedirectBackError
                 redirect_to :controller => 'users', :action => 'edit', :id => @user
               end
               def edit_membership
                 @user = User.find(params[:id])
                 @membership = Member.edit_membership(params[:membership_id], params[:membership], @user)
                 @membership.save if request.post?
                 respond_to do |format|
                   if @membership.valid?
                     format.html { redirect_to :controller => 'users', :action => 'edit', :id => @user, :tab => 'memberships' }
                     format.js {
                       render(:update) {|page|
                         page.replace_html "tab-content-memberships", :partial => 'users/memberships'
                         page.visual_effect(:highlight, "member-#{@membership.id}")
                       }
                     }
                   else
                     format.js {
                       render(:update) {|page|
                         page.alert(l(:notice_failed_to_save_members, :errors => @membership.errors.full_messages.join(', ')))
                       }
                     }
                   end
                 end
               end
               def destroy_membership
                 @user = User.find(params[:id])
                 @membership = Member.find(params[:membership_id])
                 if request.post? && @membership.deletable?
                   @membership.destroy
                 end
                 respond_to do |format|
                   format.html { redirect_to :controller => 'users', :action => 'edit', :id => @user, :tab => 'memberships' }
                   format.js { render(:update) {|page| page.replace_html "tab-content-memberships", :partial => 'users/memberships'} }
                 end
               end
             end

app/models/user.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2009  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 "digest/sha1"
             class User < Principal
               # Account statuses
               STATUS_ANONYMOUS  = 0
               STATUS_ACTIVE     = 1
               STATUS_REGISTERED = 2
               STATUS_LOCKED     = 3
               USER_FORMATS = {
                 :firstname_lastname => '#{firstname} #{lastname}',
                 :firstname => '#{firstname}',
                 :lastname_firstname => '#{lastname} #{firstname}',
                 :lastname_coma_firstname => '#{lastname}, #{firstname}',
                 :username => '#{login}'
               }
               MAIL_NOTIFICATION_OPTIONS = [
                                            [:all, :label_user_mail_option_all],
                                            [:selected, :label_user_mail_option_selected],
                                            [:none, :label_user_mail_option_none],
                                            [:only_my_events, :label_user_mail_option_only_my_events],
                                            [:only_assigned, :label_user_mail_option_only_assigned],
                                            [:only_owner, :label_user_mail_option_only_owner]
                                           ]
               has_and_belongs_to_many :groups, :after_add => Proc.new {|user, group| group.user_added(user)},
                                                :after_remove => Proc.new {|user, group| group.user_removed(user)}
               has_many :issue_categories, :foreign_key => 'assigned_to_id', :dependent => :nullify
               has_many :changesets, :dependent => :nullify
               has_one :preference, :dependent => :destroy, :class_name => 'UserPreference'
               has_one :rss_token, :dependent => :destroy, :class_name => 'Token', :conditions => "action='feeds'"
               has_one :api_token, :dependent => :destroy, :class_name => 'Token', :conditions => "action='api'"
               belongs_to :auth_source
               # Active non-anonymous users scope
               named_scope :active, :conditions => "#{User.table_name}.status = #{STATUS_ACTIVE}"
               acts_as_customizable
               attr_accessor :password, :password_confirmation
               attr_accessor :last_before_login_on
               # Prevents unauthorized assignments
               attr_protected :login, :admin, :password, :password_confirmation, :hashed_password, :group_ids
               validates_presence_of :login, :firstname, :lastname, :mail, :if => Proc.new { |user| !user.is_a?(AnonymousUser) }
               validates_uniqueness_of :login, :if => Proc.new { |user| !user.login.blank? }, :case_sensitive => false
               validates_uniqueness_of :mail, :if => Proc.new { |user| !user.mail.blank? }, :case_sensitive => false
               # Login must contain lettres, numbers, underscores only
               validates_format_of :login, :with => /^[a-z0-9_\-@\.]*$/i
               validates_length_of :login, :maximum => 30
               validates_format_of :firstname, :lastname, :with => /^[\w\s\'\-\.]*$/i
               validates_length_of :firstname, :lastname, :maximum => 30
               validates_format_of :mail, :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i, :allow_nil => true
               validates_length_of :mail, :maximum => 60, :allow_nil => true
               validates_confirmation_of :password, :allow_nil => true
               def before_create
-                self.mail_notification = Setting.default_notification_option
+                self.mail_notification = Setting.default_notification_option if self.mail_notification.blank?
                 true
               end
               def before_save
                 # update hashed_password if password was set
                 self.hashed_password = User.hash_password(self.password) if self.password && self.auth_source_id.blank?
               end
               def reload(*args)
                 @name = nil
                 super
               end
               def mail=(arg)
                 write_attribute(:mail, arg.to_s.strip)
               end
               def identity_url=(url)
                 if url.blank?
                   write_attribute(:identity_url, '')
                 else
                   begin
                     write_attribute(:identity_url, OpenIdAuthentication.normalize_identifier(url))
                   rescue OpenIdAuthentication::InvalidOpenId
                     # Invlaid url, don't save
                   end
                 end
                 self.read_attribute(:identity_url)
               end
               # Returns the user that matches provided login and password, or nil
               def self.try_to_login(login, password)
                 # Make sure no one can sign in with an empty password
                 return nil if password.to_s.empty?
                 user = find_by_login(login)
                 if user
                   # user is already in local database
                   return nil if !user.active?
                   if user.auth_source
                     # user has an external authentication method
                     return nil unless user.auth_source.authenticate(login, password)
                   else
                     # authentication with local password
                     return nil unless User.hash_password(password) == user.hashed_password
                   end
                 else
                   # user is not yet registered, try to authenticate with available sources
                   attrs = AuthSource.authenticate(login, password)
                   if attrs
                     user = new(attrs)
                     user.login = login
                     user.language = Setting.default_language
                     if user.save
                       user.reload
                       logger.info("User '#{user.login}' created from external auth source: #{user.auth_source.type} - #{user.auth_source.name}") if logger && user.auth_source
                     end
                   end
                 end
                 user.update_attribute(:last_login_on, Time.now) if user && !user.new_record?
                 user
               rescue => text
                 raise text
               end
               # Returns the user who matches the given autologin +key+ or nil
               def self.try_to_autologin(key)
                 tokens = Token.find_all_by_action_and_value('autologin', key)
                 # Make sure there's only 1 token that matches the key
                 if tokens.size == 1
                   token = tokens.first
                   if (token.created_on > Setting.autologin.to_i.day.ago) && token.user && token.user.active?
                     token.user.update_attribute(:last_login_on, Time.now)
                     token.user
                   end
                 end
               end
               # Return user's full name for display
               def name(formatter = nil)
                 if formatter
                   eval('"' + (USER_FORMATS[formatter] || USER_FORMATS[:firstname_lastname]) + '"')
                 else
                   @name ||= eval('"' + (USER_FORMATS[Setting.user_format] || USER_FORMATS[:firstname_lastname]) + '"')
                 end
               end
               def active?
                 self.status == STATUS_ACTIVE
               end
               def registered?
                 self.status == STATUS_REGISTERED
               end
               def locked?
                 self.status == STATUS_LOCKED
               end
               def activate
                 self.status = STATUS_ACTIVE
               end
               def register
                 self.status = STATUS_REGISTERED
               end
               def lock
                 self.status = STATUS_LOCKED
               end
               def activate!
                 update_attribute(:status, STATUS_ACTIVE)
               end
               def register!
                 update_attribute(:status, STATUS_REGISTERED)
               end
               def lock!
                 update_attribute(:status, STATUS_LOCKED)
               end
               def check_password?(clear_password)
                 if auth_source_id.present?
                   auth_source.authenticate(self.login, clear_password)
                 else
                   User.hash_password(clear_password) == self.hashed_password
                 end
               end
               # Does the backend storage allow this user to change their password?
               def change_password_allowed?
                 return true if auth_source_id.blank?
                 return auth_source.allow_password_changes?
               end
               # Generate and set a random password.  Useful for automated user creation
               # Based on Token#generate_token_value
               #
               def random_password
                 chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
                 password = ''
 .times { |i| password << chars[rand(chars.size-1)] }
                 self.password = password
                 self.password_confirmation = password
                 self
               end
               def pref
                 self.preference ||= UserPreference.new(:user => self)
               end
               def time_zone
                 @time_zone ||= (self.pref.time_zone.blank? ? nil : ActiveSupport::TimeZone[self.pref.time_zone])
               end
               def wants_comments_in_reverse_order?
                 self.pref[:comments_sorting] == 'desc'
               end
               # Return user's RSS key (a 40 chars long string), used to access feeds
               def rss_key
                 token = self.rss_token || Token.create(:user => self, :action => 'feeds')
                 token.value
               end
               # Return user's API key (a 40 chars long string), used to access the API
               def api_key
                 token = self.api_token || self.create_api_token(:action => 'api')
                 token.value
               end
               # Return an array of project ids for which the user has explicitly turned mail notifications on
               def notified_projects_ids
                 @notified_projects_ids ||= memberships.select {|m| m.mail_notification?}.collect(&:project_id)
               end
               def notified_project_ids=(ids)
                 Member.update_all("mail_notification = #{connection.quoted_false}", ['user_id = ?', id])
                 Member.update_all("mail_notification = #{connection.quoted_true}", ['user_id = ? AND project_id IN (?)', id, ids]) if ids && !ids.empty?
                 @notified_projects_ids = nil
                 notified_projects_ids
               end
               # Find a user account by matching the exact login and then a case-insensitive
               # version.  Exact matches will be given priority.
               def self.find_by_login(login)
                 # force string comparison to be case sensitive on MySQL
                 type_cast = (ActiveRecord::Base.connection.adapter_name == 'MySQL') ? 'BINARY' : ''
                 # First look for an exact match
                 user = first(:conditions => ["#{type_cast} login = ?", login])
                 # Fail over to case-insensitive if none was found
                 user ||= first(:conditions => ["#{type_cast} LOWER(login) = ?", login.to_s.downcase])
               end
               def self.find_by_rss_key(key)
                 token = Token.find_by_value(key)
                 token && token.user.active? ? token.user : nil
               end
               def self.find_by_api_key(key)
                 token = Token.find_by_action_and_value('api', key)
                 token && token.user.active? ? token.user : nil
               end
               # Makes find_by_mail case-insensitive
               def self.find_by_mail(mail)
                 find(:first, :conditions => ["LOWER(mail) = ?", mail.to_s.downcase])
               end
               def to_s
                 name
               end
               # Returns the current day according to user's time zone
               def today
                 if time_zone.nil?
                   Date.today
                 else
                   Time.now.in_time_zone(time_zone).to_date
                 end
               end
               def logged?
                 true
               end
               def anonymous?
                 !logged?
               end
               # Return user's roles for project
               def roles_for_project(project)
                 roles = []
                 # No role on archived projects
                 return roles unless project && project.active?
                 if logged?
                   # Find project membership
                   membership = memberships.detect {|m| m.project_id == project.id}
                   if membership
                     roles = membership.roles
                   else
                     @role_non_member ||= Role.non_member
                     roles << @role_non_member
                   end
                 else
                   @role_anonymous ||= Role.anonymous
                   roles << @role_anonymous
                 end
                 roles
               end
               # Return true if the user is a member of project
               def member_of?(project)
                 !roles_for_project(project).detect {|role| role.member?}.nil?
               end
               # Return true if the user is allowed to do the specified action on project
               # action can be:
               # * a parameter-like Hash (eg. :controller => 'projects', :action => 'edit')
               # * a permission Symbol (eg. :edit_project)
               def allowed_to?(action, project, options={})
                 if project
                   # No action allowed on archived projects
                   return false unless project.active?
                   # No action allowed on disabled modules
                   return false unless project.allows_to?(action)
                   # Admin users are authorized for anything else
                   return true if admin?
                   roles = roles_for_project(project)
                   return false unless roles
                   roles.detect {|role| (project.is_public? || role.member?) && role.allowed_to?(action)}
                 elsif options[:global]
                   # Admin users are always authorized
                   return true if admin?
                   # authorize if user has at least one role that has this permission
                   roles = memberships.collect {|m| m.roles}.flatten.uniq
                   roles.detect {|r| r.allowed_to?(action)} || (self.logged? ? Role.non_member.allowed_to?(action) : Role.anonymous.allowed_to?(action))
                 else
                   false
                 end
               end
               # Is the user allowed to do the specified action on any project?
               # See allowed_to? for the actions and valid options.
               def allowed_to_globally?(action, options)
                 allowed_to?(action, nil, options.reverse_merge(:global => true))
               end
               # Utility method to help check if a user should be notified about an
               # event.
               #
               # TODO: only supports Issue events currently
               def notify_about?(object)
                 case mail_notification.to_sym
                 when :all
                   true
                 when :selected
                   # Handled by the Project
                 when :none
                   false
                 when :only_my_events
                   if object.is_a?(Issue) && (object.author == self || object.assigned_to == self)
                     true
                   else
                     false
                   end
                 when :only_assigned
                   if object.is_a?(Issue) && object.assigned_to == self
                     true
                   else
                     false
                   end
                 when :only_owner
                   if object.is_a?(Issue) && object.author == self
                     true
                   else
                     false
                   end
                 else
                   false
                 end
               end
               def self.current=(user)
                 @current_user = user
               end
               def self.current
                 @current_user ||= User.anonymous
               end
               # Returns the anonymous user.  If the anonymous user does not exist, it is created.  There can be only
               # one anonymous user per database.
               def self.anonymous
                 anonymous_user = AnonymousUser.find(:first)
                 if anonymous_user.nil?
                   anonymous_user = AnonymousUser.create(:lastname => 'Anonymous', :firstname => '', :mail => '', :login => '', :status => 0)
                   raise 'Unable to create the anonymous user.' if anonymous_user.new_record?
                 end
                 anonymous_user
               end
               protected
               def validate
                 # Password length validation based on setting
                 if !password.nil? && password.size < Setting.password_min_length.to_i
                   errors.add(:password, :too_short, :count => Setting.password_min_length.to_i)
                 end
               end
               private
               # Return password digest
               def self.hash_password(clear_password)
                 Digest::SHA1.hexdigest(clear_password || "")
               end
             end
             class AnonymousUser < User
               def validate_on_create
                 # There should be only one AnonymousUser in the database
                 errors.add_to_base 'An anonymous user already exists.' if AnonymousUser.find(:first)
               end
               def available_custom_fields
                 []
               end
               # Overrides a few properties
               def logged?; false end
               def admin; false end
               def name(*args); I18n.t(:label_user_anonymous) end
               def mail; nil end
               def time_zone; nil end
               def rss_key; nil end
             end

app/views/my/account.rhtml +2 -14

             <div class="contextual">
             <%= link_to(l(:button_change_password), :action => 'password') if @user.change_password_allowed? %>
             <%= call_hook(:view_my_account_contextual, :user => @user)%>
             </div>
             <h2><%=l(:label_my_account)%></h2>
             <%= error_messages_for 'user' %>
             <% form_for :user, @user, :url => { :action => "account" },
                                       :builder => TabularFormBuilder,
                                       :lang => current_language,
                                       :html => { :id => 'my_account_form' } do |f| %>
             <div class="splitcontentleft">
             <h3><%=l(:label_information_plural)%></h3>
             <div class="box tabular">
             <p><%= f.text_field :firstname, :required => true %></p>
             <p><%= f.text_field :lastname, :required => true %></p>
             <p><%= f.text_field :mail, :required => true %></p>
             <p><%= f.select :language, lang_options_for_select %></p>
             <% if Setting.openid? %>
             <p><%= f.text_field :identity_url  %></p>
             <% end %>
             <% @user.custom_field_values.select(&:editable?).each do |value| %>
             	<p><%= custom_field_tag_with_label :user, value %></p>
             <% end %>
             <%= call_hook(:view_my_account, :user => @user, :form => f) %>
             </div>
             <%= submit_tag l(:button_save) %>
             </div>
             <div class="splitcontentright">
             <h3><%=l(:field_mail_notification)%></h3>
             <div class="box">
-            <%= select_tag 'notification_option', options_for_select(@notification_options.collect {|o| [l(o.last), o.first]}, @notification_option.to_sym),
+            <%= render :partial => 'users/mail_notifications' %>
-                                                  :onchange => 'if ($("notification_option").value == "selected") {Element.show("notified-projects")} else {Element.hide("notified-projects")}' %>
-            <% content_tag 'div', :id => 'notified-projects', :style => (@notification_option == 'selected' ? '' : 'display:none;') do %>
-            <p><% User.current.projects.each do |project| %>
-                <label><%= check_box_tag 'notified_project_ids[]', project.id, @user.notified_projects_ids.include?(project.id) %> <%=h project.name %></label><br />
-            <% end %></p>
-            <p><em><%= l(:text_user_mail_option) %></em></p>
-            <% end %>
-            <p><label><%= check_box_tag 'no_self_notified', 1, @user.pref[:no_self_notified] %> <%= l(:label_user_mail_no_self_notified) %></label></p>
             </div>
             <h3><%=l(:label_preferences)%></h3>
             <div class="box tabular">
-            <% fields_for :pref, @user.pref, :builder => TabularFormBuilder, :lang => current_language do |pref_fields| %>
+            <%= render :partial => 'users/preferences' %>
-            <p><%= pref_fields.check_box :hide_mail %></p>
-            <p><%= pref_fields.select :time_zone, ActiveSupport::TimeZone.all.collect {|z| [ z.to_s, z.name ]}, :include_blank => true %></p>
-            <p><%= pref_fields.select :comments_sorting, [[l(:label_chronological_order), 'asc'], [l(:label_reverse_chronological_order), 'desc']] %></p>
-            <% end %>
             </div>
             </div>
             <% end %>
             <% content_for :sidebar do %>
             <%= render :partial => 'sidebar' %>
             <% end %>
             <% html_title(l(:label_my_account)) -%>

app/views/users/_form.rhtml +10 0

             <%= error_messages_for 'user' %>
             <!--[form:user]-->
             <div class="box tabular">
             <p><%= f.text_field :login, :required => true, :size => 25  %></p>
             <p><%= f.text_field :firstname, :required => true %></p>
             <p><%= f.text_field :lastname, :required => true %></p>
             <p><%= f.text_field :mail, :required => true %></p>
             <p><%= f.select :language, lang_options_for_select %></p>
             <% if Setting.openid? %>
             <p><%= f.text_field :identity_url  %></p>
             <% end %>
             <% @user.custom_field_values.each do |value| %>
             	<p><%= custom_field_tag_with_label :user, value %></p>
             <% end %>
             <p><%= f.check_box :admin, :disabled => (@user == User.current) %></p>
             <%= call_hook(:view_users_form, :user => @user, :form => f) %>
             </div>
             <div class="box tabular">
             <h3><%=l(:label_authentication)%></h3>
             <% unless @auth_sources.empty? %>
             <p><%= f.select :auth_source_id, ([[l(:label_internal), ""]] + @auth_sources.collect { |a| [a.name, a.id] }), {}, :onchange => "if (this.value=='') {Element.show('password_fields');} else {Element.hide('password_fields');}" %></p>
             <% end %>
             <div id="password_fields" style="<%= 'display:none;' if @user.auth_source %>">
             <p><label for="password"><%=l(:field_password)%><span class="required"> *</span></label>
             <%= password_field_tag 'password', nil, :size => 25  %><br />
             <em><%= l(:text_caracters_minimum, :count => Setting.password_min_length) %></em></p>
             <p><label for="password_confirmation"><%=l(:field_password_confirmation)%><span class="required"> *</span></label>
             <%= password_field_tag 'password_confirmation', nil, :size => 25  %></p>
             </div>
             </div>
+            <div class="box">
+            <h3><%=l(:field_mail_notification)%></h3>
+            <%= render :partial => 'users/mail_notifications' %>
+            </div>
+            <div class="box tabular">
+            <h3><%=l(:label_preferences)%></h3>
+            <%= render :partial => 'users/preferences' %>
+            </div>
             <!--[eoform:user]-->

test/functional/users_controller_test.rb +14 -3

             # 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.
             require File.dirname(__FILE__) + '/../test_helper'
             require 'users_controller'
             # Re-raise errors caught by the controller.
             class UsersController; def rescue_action(e) raise e end; end
             class UsersControllerTest < ActionController::TestCase
               include Redmine::I18n
               fixtures :users, :projects, :members, :member_roles, :roles, :auth_sources
               def setup
                 @controller = UsersController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
                 @request.session[:user_id] = 1 # admin
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:users)
                 # active users only
                 assert_nil assigns(:users).detect {|u| !u.active?}
               end
               def test_index_with_name_filter
                 get :index, :name => 'john'
                 assert_response :success
                 assert_template 'index'
                 users = assigns(:users)
                 assert_not_nil users
                 assert_equal 1, users.size
                 assert_equal 'John', users.first.firstname
               end
               def test_show
                 @request.session[:user_id] = nil
                 get :show, :id => 2
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:user)
               end
               def test_show_should_not_fail_when_custom_values_are_nil
                 user = User.find(2)
                 # Create a custom field to illustrate the issue
                 custom_field = CustomField.create!(:name => 'Testing', :field_format => 'text')
                 custom_value = user.custom_values.build(:custom_field => custom_field).save!
                 get :show, :id => 2
                 assert_response :success
               end
               def test_show_inactive
                 @request.session[:user_id] = nil
                 get :show, :id => 5
                 assert_response 404
               end
               def test_show_should_not_reveal_users_with_no_visible_activity_or_project
                 @request.session[:user_id] = nil
                 get :show, :id => 9
                 assert_response 404
               end
               def test_show_inactive_by_admin
                 @request.session[:user_id] = 1
                 get :show, :id => 5
                 assert_response 200
                 assert_not_nil assigns(:user)
               end
               def test_show_displays_memberships_based_on_project_visibility
                 @request.session[:user_id] = 1
                 get :show, :id => 2
                 assert_response :success
                 memberships = assigns(:memberships)
                 assert_not_nil memberships
                 project_ids = memberships.map(&:project_id)
                 assert project_ids.include?(2) #private project admin can see
               end
               context "GET :add" do
                 setup do
                   get :add
                 end
                 should_assign_to :user
                 should_respond_with :success
                 should_render_template :add
               end
               context "POST :create" do
                 context "when successful" do
                   setup do
                     post :create, :user => {
                       :firstname => 'John',
                       :lastname => 'Doe',
                       :login => 'jdoe',
                       :password => 'test',
                       :password_confirmation => 'test',
                       :mail => 'jdoe@gmail.com'
+                    },
+                    :notification_option => 'none'
                   end
                   should_assign_to :user
                   should_respond_with :redirect
                   should_redirect_to('user edit') { {:controller => 'users', :action => 'edit', :id => User.find_by_login('jdoe')}}
+                  should 'set the users mail notification' do
+                    user = User.last
+                    assert_equal 'none', user.mail_notification
+                  end
                 end
                 context "when unsuccessful" do
                   setup do
                     post :create, :user => {}
                   end
                   should_assign_to :user
                   should_respond_with :success
                   should_render_template :add
                 end
               end
               def test_edit
                 ActionMailer::Base.deliveries.clear
-                post :edit, :id => 2, :user => {:firstname => 'Changed'}
+                post :edit, :id => 2, :user => {:firstname => 'Changed'}, :notification_option => 'all', :pref => {:hide_mail => '1', :comments_sorting => 'desc'}
-                assert_equal 'Changed', User.find(2).firstname
+                user = User.find(2)
+                assert_equal 'Changed', user.firstname
+                assert_equal 'all', user.mail_notification
+                assert_equal true, user.pref[:hide_mail]
+                assert_equal 'desc', user.pref[:comments_sorting]
                 assert ActionMailer::Base.deliveries.empty?
               end
               def test_edit_with_activation_should_send_a_notification
                 u = User.new(:firstname => 'Foo', :lastname => 'Bar', :mail => 'foo.bar@somenet.foo', :language => 'fr')
                 u.login = 'foo'
                 u.status = User::STATUS_REGISTERED
                 u.save!
                 ActionMailer::Base.deliveries.clear
                 Setting.bcc_recipients = '1'
                 post :edit, :id => u.id, :user => {:status => User::STATUS_ACTIVE}
                 assert u.reload.active?
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert_equal ['foo.bar@somenet.foo'], mail.bcc
                 assert mail.body.include?(ll('fr', :notice_account_activated))
               end
               def test_edit_with_password_change_should_send_a_notification
                 ActionMailer::Base.deliveries.clear
                 Setting.bcc_recipients = '1'
                 u = User.find(2)
                 post :edit, :id => u.id, :user => {}, :password => 'newpass', :password_confirmation => 'newpass', :send_information => '1'
                 assert_equal User.hash_password('newpass'), u.reload.hashed_password
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert_equal [u.mail], mail.bcc
                 assert mail.body.include?('newpass')
               end
               test "POST :edit with a password change to an AuthSource user switching to Internal authentication" do
                 # Configure as auth source
                 u = User.find(2)
                 u.auth_source = AuthSource.find(1)
                 u.save!
                 post :edit, :id => u.id, :user => {:auth_source_id => ''}, :password => 'newpass', :password_confirmation => 'newpass'
                 assert_equal nil, u.reload.auth_source
                 assert_equal User.hash_password('newpass'), u.reload.hashed_password
               end
               def test_edit_membership
                 post :edit_membership, :id => 2, :membership_id => 1,
                                        :membership => { :role_ids => [2]}
                 assert_redirected_to :action => 'edit', :id => '2', :tab => 'memberships'
                 assert_equal [2], Member.find(1).role_ids
               end
               def test_destroy_membership
                 post :destroy_membership, :id => 2, :membership_id => 1
                 assert_redirected_to :action => 'edit', :id => '2', :tab => 'memberships'
                 assert_nil Member.find_by_id(1)
               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