jro_apps/redmine Commit - r1777:696d21f8c8c8

Adds cross-project time reports support (#994)....

Jean-Philippe Lang -

r1777:696d21f8c8c8

parent child

Context file:

r1777:696d21f8c8c8

Collapse all files

app/controllers/application.rb +5 -1

             # 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 'uri'
             class ApplicationController < ActionController::Base
               layout 'base'
               before_filter :user_setup, :check_if_login_required, :set_localization
               filter_parameter_logging :password
               include Redmine::MenuManager::MenuController
               helper Redmine::MenuManager::MenuHelper
               REDMINE_SUPPORTED_SCM.each do |scm|
                 require_dependency "repository/#{scm.underscore}"
               end
               def current_role
                 @current_role ||= User.current.role_for_project(@project)
               end
               def user_setup
                 # Check the settings cache for each request
                 Setting.check_cache
                 # Find the current user
                 User.current = find_current_user
               end
               # Returns the current user or nil if no user is logged in
               def find_current_user
                 if session[:user_id]
                   # existing session
                   (User.find_active(session[:user_id]) rescue nil)
                 elsif cookies[:autologin] && Setting.autologin?
                   # auto-login feature
                   User.find_by_autologin_key(cookies[:autologin])
                 elsif params[:key] && accept_key_auth_actions.include?(params[:action])
                   # RSS key authentication
                   User.find_by_rss_key(params[:key])
                 end
               end
               # check if login is globally required to access the application
               def check_if_login_required
                 # no check needed if user is already logged in
                 return true if User.current.logged?
                 require_login if Setting.login_required?
               end
               def set_localization
                 User.current.language = nil unless User.current.logged?
                 lang = begin
                   if !User.current.language.blank? && GLoc.valid_language?(User.current.language)
                     User.current.language
                   elsif request.env['HTTP_ACCEPT_LANGUAGE']
                     accept_lang = parse_qvalues(request.env['HTTP_ACCEPT_LANGUAGE']).first.downcase
                     if !accept_lang.blank? && (GLoc.valid_language?(accept_lang) || GLoc.valid_language?(accept_lang = accept_lang.split('-').first))
                       User.current.language = accept_lang
                     end
                   end
                 rescue
                   nil
                 end || Setting.default_language
                 set_language_if_valid(lang)
               end
               def require_login
                 if !User.current.logged?
                   redirect_to :controller => "account", :action => "login", :back_url => request.request_uri
                   return false
                 end
                 true
               end
               def require_admin
                 return unless require_login
                 if !User.current.admin?
                   render_403
                   return false
                 end
                 true
               end
+              def deny_access
+                User.current.logged? ? render_403 : require_login
+              end
               # Authorize the user for the requested action
               def authorize(ctrl = params[:controller], action = params[:action])
                 allowed = User.current.allowed_to?({:controller => ctrl, :action => action}, @project)
-                allowed ? true : (User.current.logged? ? render_403 : require_login)
+                allowed ? true : deny_access
               end
               # make sure that the user is a member of the project (or admin) if project is private
               # used as a before_filter for actions that do not require any particular permission on the project
               def check_project_privacy
                 if @project && @project.active?
                   if @project.is_public? || User.current.member_of?(@project) || User.current.admin?
                     true
                   else
                     User.current.logged? ? render_403 : require_login
                   end
                 else
                   @project = nil
                   render_404
                   false
                 end
               end
               def redirect_back_or_default(default)
                 back_url = params[:back_url]
                 if !back_url.blank?
                   uri = URI.parse(back_url)
                   # do not redirect user to another host
                   if uri.relative? || (uri.host == request.host)
                     redirect_to(back_url) and return
                   end
                 end
                 redirect_to default
               end
               def render_403
                 @project = nil
                 render :template => "common/403", :layout => !request.xhr?, :status => 403
                 return false
               end
               def render_404
                 render :template => "common/404", :layout => !request.xhr?, :status => 404
                 return false
               end
               def render_error(msg)
                 flash.now[:error] = msg
                 render :nothing => true, :layout => !request.xhr?, :status => 500
               end
               def render_feed(items, options={})
                 @items = items || []
                 @items.sort! {|x,y| y.event_datetime <=> x.event_datetime }
                 @items = @items.slice(0, Setting.feeds_limit.to_i)
                 @title = options[:title] || Setting.app_title
                 render :template => "common/feed.atom.rxml", :layout => false, :content_type => 'application/atom+xml'
               end
               def self.accept_key_auth(*actions)
                 actions = actions.flatten.map(&:to_s)
                 write_inheritable_attribute('accept_key_auth_actions', actions)
               end
               def accept_key_auth_actions
                 self.class.read_inheritable_attribute('accept_key_auth_actions') || []
               end
               # TODO: move to model
               def attach_files(obj, attachments)
                 attached = []
                 if attachments && attachments.is_a?(Hash)
                   attachments.each_value do |attachment|
                     file = attachment['file']
                     next unless file && file.size > 0
                     a = Attachment.create(:container => obj,
                                           :file => file,
                                           :description => attachment['description'].to_s.strip,
                                           :author => User.current)
                     attached << a unless a.new_record?
                   end
                 end
                 attached
               end
               # Returns the number of objects that should be displayed
               # on the paginated list
               def per_page_option
                 per_page = nil
                 if params[:per_page] && Setting.per_page_options_array.include?(params[:per_page].to_s.to_i)
                   per_page = params[:per_page].to_s.to_i
                   session[:per_page] = per_page
                 elsif session[:per_page]
                   per_page = session[:per_page]
                 else
                   per_page = Setting.per_page_options_array.first || 25
                 end
                 per_page
               end
               # qvalues http header parser
               # code taken from webrick
               def parse_qvalues(value)
                 tmp = []
                 if value
                   parts = value.split(/,\s*/)
                   parts.each {|part|
                     if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
                       val = m[1]
                       q = (m[2] or 1).to_f
                       tmp.push([val, q])
                     end
                   }
                   tmp = tmp.sort_by{|val, q| -q}
                   tmp.collect!{|val, q| val}
                 end
                 return tmp
               end
               # Returns a string that can be used as filename value in Content-Disposition header
               def filename_for_content_disposition(name)
                 request.env['HTTP_USER_AGENT'] =~ %r{MSIE} ? ERB::Util.url_encode(name) : name
               end
             end

app/controllers/timelog_controller.rb +29 -11

             # 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 TimelogController < ApplicationController
               menu_item :issues
-              before_filter :find_project, :authorize
+              before_filter :find_project, :authorize, :only => [:edit, :destroy]
+              before_filter :find_optional_project, :only => [:report, :details]
               verify :method => :post, :only => :destroy, :redirect_to => { :action => :details }
               helper :sort
               include SortHelper
               helper :issues
               include TimelogHelper
               helper :custom_fields
               include CustomFieldsHelper
               def report
                 @available_criterias = { 'project' => {:sql => "#{TimeEntry.table_name}.project_id",
                                                       :klass => Project,
                                                       :label => :label_project},
                                          'version' => {:sql => "#{Issue.table_name}.fixed_version_id",
                                                       :klass => Version,
                                                       :label => :label_version},
                                          'category' => {:sql => "#{Issue.table_name}.category_id",
                                                         :klass => IssueCategory,
                                                         :label => :field_category},
                                          'member' => {:sql => "#{TimeEntry.table_name}.user_id",
                                                      :klass => User,
                                                      :label => :label_member},
                                          'tracker' => {:sql => "#{Issue.table_name}.tracker_id",
                                                       :klass => Tracker,
                                                       :label => :label_tracker},
                                          'activity' => {:sql => "#{TimeEntry.table_name}.activity_id",
                                                        :klass => Enumeration,
                                                        :label => :label_activity},
                                          'issue' => {:sql => "#{TimeEntry.table_name}.issue_id",
                                                      :klass => Issue,
                                                      :label => :label_issue}
                                        }
                 # Add list and boolean custom fields as available criterias
-                @project.all_issue_custom_fields.select {|cf| %w(list bool).include? cf.field_format }.each do |cf|
+                custom_fields = (@project.nil? ? IssueCustomField.for_all : @project.all_issue_custom_fields)
+                custom_fields.select {|cf| %w(list bool).include? cf.field_format }.each do |cf|
                   @available_criterias["cf_#{cf.id}"] = {:sql => "(SELECT c.value FROM #{CustomValue.table_name} c WHERE c.custom_field_id = #{cf.id} AND c.customized_type = 'Issue' AND c.customized_id = #{Issue.table_name}.id)",
                                                          :format => cf.field_format,
                                                          :label => cf.name}
-                end
+                end if @project
                 # Add list and boolean time entry custom fields
                 TimeEntryCustomField.find(:all).select {|cf| %w(list bool).include? cf.field_format }.each do |cf|
                   @available_criterias["cf_#{cf.id}"] = {:sql => "(SELECT c.value FROM #{CustomValue.table_name} c WHERE c.custom_field_id = #{cf.id} AND c.customized_type = 'TimeEntry' AND c.customized_id = #{TimeEntry.table_name}.id)",
                                                          :format => cf.field_format,
                                                          :label => cf.name}
                 end
                 @criterias = params[:criterias] || []
                 @criterias = @criterias.select{|criteria| @available_criterias.has_key? criteria}
                 @criterias.uniq!
                 @criterias = @criterias[0,3]
                 @columns = (params[:columns] && %w(year month week day).include?(params[:columns])) ? params[:columns] : 'month'
                 retrieve_date_range
                 unless @criterias.empty?
                   sql_select = @criterias.collect{|criteria| @available_criterias[criteria][:sql] + " AS " + criteria}.join(', ')
                   sql_group_by = @criterias.collect{|criteria| @available_criterias[criteria][:sql]}.join(', ')
                   sql = "SELECT #{sql_select}, tyear, tmonth, tweek, spent_on, SUM(hours) AS hours"
                   sql << " FROM #{TimeEntry.table_name}"
                   sql << " LEFT JOIN #{Issue.table_name} ON #{TimeEntry.table_name}.issue_id = #{Issue.table_name}.id"
                   sql << " LEFT JOIN #{Project.table_name} ON #{TimeEntry.table_name}.project_id = #{Project.table_name}.id"
-                  sql << " WHERE (%s)" % @project.project_condition(Setting.display_subprojects_issues?)
+                  sql << " WHERE"
-                  sql << " AND (%s)" % Project.allowed_to_condition(User.current, :view_time_entries)
+                  sql << " (%s) AND" % @project.project_condition(Setting.display_subprojects_issues?) if @project
-                  sql << " AND spent_on BETWEEN '%s' AND '%s'" % [ActiveRecord::Base.connection.quoted_date(@from.to_time), ActiveRecord::Base.connection.quoted_date(@to.to_time)]
+                  sql << " (%s) AND" % Project.allowed_to_condition(User.current, :view_time_entries)
+                  sql << " (spent_on BETWEEN '%s' AND '%s')" % [ActiveRecord::Base.connection.quoted_date(@from.to_time), ActiveRecord::Base.connection.quoted_date(@to.to_time)]
                   sql << " GROUP BY #{sql_group_by}, tyear, tmonth, tweek, spent_on"
                   @hours = ActiveRecord::Base.connection.select_all(sql)
                   @hours.each do |row|
                     case @columns
                     when 'year'
                       row['year'] = row['tyear']
                     when 'month'
                       row['month'] = "#{row['tyear']}-#{row['tmonth']}"
                     when 'week'
                       row['week'] = "#{row['tyear']}-#{row['tweek']}"
                     when 'day'
                       row['day'] = "#{row['spent_on']}"
                     end
                   end
                   @total_hours = @hours.inject(0) {|s,k| s = s + k['hours'].to_f}
                   @periods = []
                   # Date#at_beginning_of_ not supported in Rails 1.2.x
                   date_from = @from.to_time
                   # 100 columns max
                   while date_from <= @to.to_time && @periods.length < 100
                     case @columns
                     when 'year'
                       @periods << "#{date_from.year}"
                       date_from = (date_from + 1.year).at_beginning_of_year
                     when 'month'
                       @periods << "#{date_from.year}-#{date_from.month}"
                       date_from = (date_from + 1.month).at_beginning_of_month
                     when 'week'
                       @periods << "#{date_from.year}-#{date_from.to_date.cweek}"
                       date_from = (date_from + 7.day).at_beginning_of_week
                     when 'day'
                       @periods << "#{date_from.to_date}"
                       date_from = date_from + 1.day
                     end
                   end
                 end
                 respond_to do |format|
                   format.html { render :layout => !request.xhr? }
                   format.csv  { send_data(report_to_csv(@criterias, @periods, @hours).read, :type => 'text/csv; header=present', :filename => 'timelog.csv') }
                 end
               end
               def details
                 sort_init 'spent_on', 'desc'
                 sort_update
                 cond = ARCondition.new
-                cond << (@issue.nil? ? @project.project_condition(Setting.display_subprojects_issues?) :
+                if @project.nil?
-                                       ["#{TimeEntry.table_name}.issue_id = ?", @issue.id])
+                  cond << Project.allowed_to_condition(User.current, :view_time_entries)
+                elsif @issue.nil?
+                  cond << @project.project_condition(Setting.display_subprojects_issues?)
+                else
+                  cond << ["#{TimeEntry.table_name}.issue_id = ?", @issue.id]
+                end
                 retrieve_date_range
                 cond << ['spent_on BETWEEN ? AND ?', @from, @to]
                 TimeEntry.visible_by(User.current) do
                   respond_to do |format|
                     format.html {
                       # Paginate results
                       @entry_count = TimeEntry.count(:include => :project, :conditions => cond.conditions)
                       @entry_pages = Paginator.new self, @entry_count, per_page_option, params['page']
                       @entries = TimeEntry.find(:all,
                                                 :include => [:project, :activity, :user, {:issue => :tracker}],
                                                 :conditions => cond.conditions,
                                                 :order => sort_clause,
                                                 :limit  =>  @entry_pages.items_per_page,
                                                 :offset =>  @entry_pages.current.offset)
                       @total_hours = TimeEntry.sum(:hours, :include => :project, :conditions => cond.conditions).to_f
                       render :layout => !request.xhr?
                     }
                     format.atom {
                       entries = TimeEntry.find(:all,
                                                :include => [:project, :activity, :user, {:issue => :tracker}],
                                                :conditions => cond.conditions,
                                                :order => "#{TimeEntry.table_name}.created_on DESC",
                                                :limit => Setting.feeds_limit.to_i)
                       render_feed(entries, :title => l(:label_spent_time))
                     }
                     format.csv {
                       # Export all entries
                       @entries = TimeEntry.find(:all,
                                                 :include => [:project, :activity, :user, {:issue => [:tracker, :assigned_to, :priority]}],
                                                 :conditions => cond.conditions,
                                                 :order => sort_clause)
                       send_data(entries_to_csv(@entries).read, :type => 'text/csv; header=present', :filename => 'timelog.csv')
                     }
                   end
                 end
               end
               def edit
                 render_403 and return if @time_entry && !@time_entry.editable_by?(User.current)
                 @time_entry ||= TimeEntry.new(:project => @project, :issue => @issue, :user => User.current, :spent_on => Date.today)
                 @time_entry.attributes = params[:time_entry]
                 if request.post? and @time_entry.save
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to(params[:back_url].blank? ? {:action => 'details', :project_id => @time_entry.project} : params[:back_url])
                   return
                 end
               end
               def destroy
                 render_404 and return unless @time_entry
                 render_403 and return unless @time_entry.editable_by?(User.current)
                 @time_entry.destroy
                 flash[:notice] = l(:notice_successful_delete)
                 redirect_to :back
-              rescue RedirectBackError
+              rescue ::ActionController::RedirectBackError
                 redirect_to :action => 'details', :project_id => @time_entry.project
               end
             private
               def find_project
                 if params[:id]
                   @time_entry = TimeEntry.find(params[:id])
                   @project = @time_entry.project
                 elsif params[:issue_id]
                   @issue = Issue.find(params[:issue_id])
                   @project = @issue.project
                 elsif params[:project_id]
                   @project = Project.find(params[:project_id])
                 else
                   render_404
                   return false
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
+              def find_optional_project
+                if !params[:issue_id].blank?
+                  @issue = Issue.find(params[:issue_id])
+                  @project = @issue.project
+                elsif !params[:project_id].blank?
+                  @project = Project.find(params[:project_id])
+                end
+                deny_access unless User.current.allowed_to?(:view_time_entries, @project, :global => true)
+              end
               # Retrieves the date range based on predefined ranges or specific from/to param dates
               def retrieve_date_range
                 @free_period = false
                 @from, @to = nil, nil
                 if params[:period_type] == '1' || (params[:period_type].nil? && !params[:period].nil?)
                   case params[:period].to_s
                   when 'today'
                     @from = @to = Date.today
                   when 'yesterday'
                     @from = @to = Date.today - 1
                   when 'current_week'
                     @from = Date.today - (Date.today.cwday - 1)%7
                     @to = @from + 6
                   when 'last_week'
                     @from = Date.today - 7 - (Date.today.cwday - 1)%7
                     @to = @from + 6
                   when '7_days'
                     @from = Date.today - 7
                     @to = Date.today
                   when 'current_month'
                     @from = Date.civil(Date.today.year, Date.today.month, 1)
                     @to = (@from >> 1) - 1
                   when 'last_month'
                     @from = Date.civil(Date.today.year, Date.today.month, 1) << 1
                     @to = (@from >> 1) - 1
                   when '30_days'
                     @from = Date.today - 30
                     @to = Date.today
                   when 'current_year'
                     @from = Date.civil(Date.today.year, 1, 1)
                     @to = Date.civil(Date.today.year, 12, 31)
                   end
                 elsif params[:period_type] == '2' || (params[:period_type].nil? && (!params[:from].nil? || !params[:to].nil?))
                   begin; @from = params[:from].to_s.to_date unless params[:from].blank?; rescue; end
                   begin; @to = params[:to].to_s.to_date unless params[:to].blank?; rescue; end
                   @free_period = true
                 else
                   # default
                 end
                 @from, @to = @to, @from if @from && @to && @from > @to
-                @from ||= (TimeEntry.minimum(:spent_on, :include => :project, :conditions => @project.project_condition(Setting.display_subprojects_issues?)) || Date.today) - 1
+                @from ||= (TimeEntry.minimum(:spent_on, :include => :project, :conditions => Project.allowed_to_condition(User.current, :view_time_entries)) || Date.today) - 1
-                @to   ||= (TimeEntry.maximum(:spent_on, :include => :project, :conditions => @project.project_condition(Setting.display_subprojects_issues?)) || Date.today)
+                @to   ||= (TimeEntry.maximum(:spent_on, :include => :project, :conditions => Project.allowed_to_condition(User.current, :view_time_entries)) || Date.today)
               end
             end

app/helpers/timelog_helper.rb +8 0

             # redMine - project management software
             # Copyright (C) 2006  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 TimelogHelper
+              def render_timelog_breadcrumb
+                links = []
+                links << link_to(l(:label_project_all), {:project_id => nil, :issue_id => nil})
+                links << link_to(h(@project), {:project_id => @project, :issue_id => nil}) if @project
+                links << link_to_issue(@issue) if @issue
+                breadcrumb links
+              end
               def activity_collection_for_select_options
                 activities = Enumeration::get_values('ACTI')
                 collection = []
                 collection << [ "--- #{l(:actionview_instancetag_blank_option)} ---", '' ] unless activities.detect(&:is_default)
                 activities.each { |a| collection << [a.name, a.id] }
                 collection
               end
               def select_hours(data, criteria, value)
                 data.select {|row| row[criteria] == value}
               end
               def sum_hours(data)
                 sum = 0
                 data.each do |row|
                   sum += row['hours'].to_f
                 end
                 sum
               end
               def options_for_period_select(value)
                 options_for_select([[l(:label_all_time), 'all'],
                                     [l(:label_today), 'today'],
                                     [l(:label_yesterday), 'yesterday'],
                                     [l(:label_this_week), 'current_week'],
                                     [l(:label_last_week), 'last_week'],
                                     [l(:label_last_n_days, 7), '7_days'],
                                     [l(:label_this_month), 'current_month'],
                                     [l(:label_last_month), 'last_month'],
                                     [l(:label_last_n_days, 30), '30_days'],
                                     [l(:label_this_year), 'current_year']],
                                     value)
               end
               def entries_to_csv(entries)
                 ic = Iconv.new(l(:general_csv_encoding), 'UTF-8')
                 decimal_separator = l(:general_csv_decimal_separator)
                 custom_fields = TimeEntryCustomField.find(:all)
                 export = StringIO.new
                 CSV::Writer.generate(export, l(:general_csv_separator)) do |csv|
                   # csv header fields
                   headers = [l(:field_spent_on),
                              l(:field_user),
                              l(:field_activity),
                              l(:field_project),
                              l(:field_issue),
                              l(:field_tracker),
                              l(:field_subject),
                              l(:field_hours),
                              l(:field_comments)
                              ]
                   # Export custom fields
                   headers += custom_fields.collect(&:name)
                   csv << headers.collect {|c| begin; ic.iconv(c.to_s); rescue; c.to_s; end }
                   # csv lines
                   entries.each do |entry|
                     fields = [l_date(entry.spent_on),
                               entry.user,
                               entry.activity,
                               entry.project,
                               (entry.issue ? entry.issue.id : nil),
                               (entry.issue ? entry.issue.tracker : nil),
                               (entry.issue ? entry.issue.subject : nil),
                               entry.hours.to_s.gsub('.', decimal_separator),
                               entry.comments
                               ]
                     fields += custom_fields.collect {|f| show_value(entry.custom_value_for(f)) }
                     csv << fields.collect {|c| begin; ic.iconv(c.to_s); rescue; c.to_s; end }
                   end
                 end
                 export.rewind
                 export
               end
               def format_criteria_value(criteria, value)
                 value.blank? ? l(:label_none) : ((k = @available_criterias[criteria][:klass]) ? k.find_by_id(value.to_i) : format_value(value, @available_criterias[criteria][:format]))
               end
               def report_to_csv(criterias, periods, hours)
                 export = StringIO.new
                 CSV::Writer.generate(export, l(:general_csv_separator)) do |csv|
                   # Column headers
                   headers = criterias.collect {|criteria| l(@available_criterias[criteria][:label]) }
                   headers += periods
                   headers << l(:label_total)
                   csv << headers.collect {|c| to_utf8(c) }
                   # Content
                   report_criteria_to_csv(csv, criterias, periods, hours)
                   # Total row
                   row = [ l(:label_total) ] + [''] * (criterias.size - 1)
                   total = 0
                   periods.each do |period|
                     sum = sum_hours(select_hours(hours, @columns, period.to_s))
                     total += sum
                     row << (sum > 0 ? "%.2f" % sum : '')
                   end
                   row << "%.2f" %total
                   csv << row
                 end
                 export.rewind
                 export
               end
               def report_criteria_to_csv(csv, criterias, periods, hours, level=0)
                 hours.collect {|h| h[criterias[level]].to_s}.uniq.each do |value|
                   hours_for_value = select_hours(hours, criterias[level], value)
                   next if hours_for_value.empty?
                   row = [''] * level
                   row << to_utf8(format_criteria_value(criterias[level], value))
                   row += [''] * (criterias.length - level - 1)
                   total = 0
                   periods.each do |period|
                     sum = sum_hours(select_hours(hours_for_value, @columns, period.to_s))
                     total += sum
                     row << (sum > 0 ? "%.2f" % sum : '')
                   end
                   row << "%.2f" %total
                   csv << row
                   if criterias.length > level + 1
                     report_criteria_to_csv(csv, criterias, periods, hours_for_value, level + 1)
                   end
                 end
               end
               def to_utf8(s)
                 @ic ||= Iconv.new(l(:general_csv_encoding), 'UTF-8')
                 begin; @ic.iconv(s.to_s); rescue; s.to_s; end
               end
             end

app/models/user.rb +1 -1

             # 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 "digest/sha1"
             class User < ActiveRecord::Base
               # 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}'
               }
               has_many :memberships, :class_name => 'Member', :include => [ :project, :role ], :conditions => "#{Project.table_name}.status=#{Project::STATUS_ACTIVE}", :order => "#{Project.table_name}.name"
               has_many :members, :dependent => :delete_all
               has_many :projects, :through => :memberships
               has_many :issue_categories, :foreign_key => 'assigned_to_id', :dependent => :nullify
               has_one :preference, :dependent => :destroy, :class_name => 'UserPreference'
               has_one :rss_token, :dependent => :destroy, :class_name => 'Token', :conditions => "action='feeds'"
               belongs_to :auth_source
               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
               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? }
               validates_uniqueness_of :mail, :if => Proc.new { |user| !user.mail.blank? }
               # 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_length_of :password, :minimum => 4, :allow_nil => true
               validates_confirmation_of :password, :allow_nil => true
               def before_create
                 self.mail_notification = false
                 true
               end
               def before_save
                 # update hashed_password if password was set
                 self.hashed_password = User.hash_password(self.password) if self.password
               end
               def self.active
                 with_scope :find => { :conditions => [ "status = ?", STATUS_ACTIVE ] } do
                   yield
                 end
               end
               def self.find_active(*args)
                 active do
                   find(*args)
                 end
               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(:first, :conditions => ["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 the LDAP") if logger
                     end
                   end
                 end
                 user.update_attribute(:last_login_on, Time.now) if user && !user.new_record?
                 user
               rescue => text
                 raise text
               end
               # Return user's full name for display
               def name(formatter = nil)
                 f = USER_FORMATS[formatter || Setting.user_format] || USER_FORMATS[:firstname_lastname]
                 eval '"' + f + '"'
               end
               def active?
                 self.status == STATUS_ACTIVE
               end
               def registered?
                 self.status == STATUS_REGISTERED
               end
               def locked?
                 self.status == STATUS_LOCKED
               end
               def check_password?(clear_password)
                 User.hash_password(clear_password) == self.hashed_password
               end
               def pref
                 self.preference ||= UserPreference.new(:user => self)
               end
               def time_zone
                 self.pref.time_zone.nil? ? nil : 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 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
               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_autologin_key(key)
                 token = Token.find_by_action_and_value('autologin', key)
                 token && (token.created_on > Setting.autologin.to_i.day.ago) && token.user.active? ? token.user : nil
               end
               def <=>(user)
                 if user.nil?
                   -1
                 elsif lastname.to_s.downcase == user.lastname.to_s.downcase
                   firstname.to_s.downcase <=> user.firstname.to_s.downcase
                 else
                   lastname.to_s.downcase <=> user.lastname.to_s.downcase
                 end
               end
               def to_s
                 name
               end
               def logged?
                 true
               end
               def anonymous?
                 !logged?
               end
               # Return user's role for project
               def role_for_project(project)
                 # No role on archived projects
                 return nil unless project && project.active?
                 if logged?
                   # Find project membership
                   membership = memberships.detect {|m| m.project_id == project.id}
                   if membership
                     membership.role
                   else
                     @role_non_member ||= Role.non_member
                   end
                 else
                   @role_anonymous ||= Role.anonymous
                 end
               end
               # Return true if the user is a member of project
               def member_of?(project)
                 role_for_project(project).member?
               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?
                   role = role_for_project(project)
                   return false unless role
                   role.allowed_to?(action) && (project.is_public? || role.member?)
                 elsif options[:global]
                   # authorize if user has at least one role that has this permission
                   roles = memberships.collect {|m| m.role}.uniq
-                  roles.detect {|r| r.allowed_to?(action)}
+                  roles.detect {|r| r.allowed_to?(action)} || (self.logged? ? Role.non_member.allowed_to?(action) : Role.anonymous.allowed_to?(action))
                 else
                   false
                 end
               end
               def self.current=(user)
                 @current_user = user
               end
               def self.current
                 @current_user ||= User.anonymous
               end
               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
             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; 'Anonymous' end
               def mail; nil end
               def time_zone; nil end
               def rss_key; nil end
             end

app/views/timelog/details.rhtml +2 -4

             <div class="contextual">
             <%= link_to_if_authorized l(:button_log_time), {:controller => 'timelog', :action => 'edit', :project_id => @project, :issue_id => @issue}, :class => 'icon icon-time' %>
             </div>
-            <h2><%= l(:label_spent_time) %></h2>
+            <%= render_timelog_breadcrumb %>
-            <% if @issue %>
+            <h2><%= l(:label_spent_time) %></h2>
-            <h3><%= link_to(@project.name, {:action => 'details', :project_id => @project}) %> / <%= link_to_issue(@issue) %></h3>
-            <% end %>
             <% form_remote_tag( :url => {}, :method => :get, :update => 'content' ) do %>
             <%= hidden_field_tag 'project_id', params[:project_id] %>
             <%= hidden_field_tag 'issue_id', params[:issue_id] if @issue %>
             <%= render :partial => 'date_range' %>
             <% end %>
             <div class="total-hours">
             <p><%= l(:label_total) %>: <%= html_hours(lwr(:label_f_hour, @total_hours)) %></p>
             </div>
             <% unless @entries.empty? %>
             <%= render :partial => 'list', :locals => { :entries => @entries }%>
             <p class="pagination"><%= pagination_links_full @entry_pages, @entry_count %></p>
             <p class="other-formats">
             <%= l(:label_export_to) %>
             <span><%= link_to 'Atom', {:issue_id => @issue, :format => 'atom', :key => User.current.rss_key}, :class => 'feed' %></span>
             <span><%= link_to 'CSV', params.merge(:format => 'csv'), :class => 'csv' %></span>
             </p>
             <% end %>
             <% html_title l(:label_spent_time), l(:label_details) %>
             <% content_for :header_tags do %>
                 <%= auto_discovery_link_tag(:atom, {:issue_id => @issue, :format => 'atom', :key => User.current.rss_key}, :title => l(:label_spent_time)) %>
             <% end %>

app/views/timelog/report.rhtml +2 0

             <div class="contextual">
             <%= link_to_if_authorized l(:button_log_time), {:controller => 'timelog', :action => 'edit', :project_id => @project, :issue_id => @issue}, :class => 'icon icon-time' %>
             </div>
+            <%= render_timelog_breadcrumb %>
             <h2><%= l(:label_spent_time) %></h2>
             <% form_remote_tag(:url => {}, :update => 'content') do %>
               <% @criterias.each do |criteria| %>
                 <%= hidden_field_tag 'criterias[]', criteria, :id => nil %>
               <% end %>
               <%= hidden_field_tag 'project_id', params[:project_id] %>
               <%= render :partial => 'date_range' %>
               <p><%= l(:label_details) %>: <%= select_tag 'columns', options_for_select([[l(:label_year), 'year'],
                                                                                         [l(:label_month), 'month'],
                                                                                         [l(:label_week), 'week'],
                                                                                         [l(:label_day_plural).titleize, 'day']], @columns),
                                                                     :onchange => "this.form.onsubmit();" %>
               <%= l(:button_add) %>: <%= select_tag('criterias[]', options_for_select([[]] + (@available_criterias.keys - @criterias).collect{|k| [l(@available_criterias[k][:label]), k]}),
                                                                       :onchange => "this.form.onsubmit();",
                                                                       :style => 'width: 200px',
                                                                       :id => nil,
                                                                       :disabled => (@criterias.length >= 3)) %>
                  <%= link_to_remote l(:button_clear), {:url => {:project_id => @project, :period_type => params[:period_type], :period => params[:period], :from => @from, :to => @to, :columns => @columns},
                                                        :update => 'content'
                                                       }, :class => 'icon icon-reload' %></p>
             <% end %>
             <% unless @criterias.empty? %>
             <div class="total-hours">
             <p><%= l(:label_total) %>: <%= html_hours(lwr(:label_f_hour, @total_hours)) %></p>
             </div>
             <% unless @hours.empty? %>
             <table class="list" id="time-report">
             <thead>
             <tr>
             <% @criterias.each do |criteria| %>
               <th><%= l(@available_criterias[criteria][:label]) %></th>
             <% end %>
             <% columns_width = (40 / (@periods.length+1)).to_i %>
             <% @periods.each do |period| %>
               <th class="period" width="<%= columns_width %>%"><%= period %></th>
             <% end %>
               <th class="total" width="<%= columns_width %>%"><%= l(:label_total) %></th>
             </tr>
             </thead>
             <tbody>
             <%= render :partial => 'report_criteria', :locals => {:criterias => @criterias, :hours => @hours, :level => 0} %>
               <tr class="total">
               <td><%= l(:label_total) %></td>
               <%= '<td></td>' * (@criterias.size - 1) %>
               <% total = 0 -%>
               <% @periods.each do |period| -%>
                 <% sum = sum_hours(select_hours(@hours, @columns, period.to_s)); total += sum -%>
                 <td class="hours"><%= html_hours("%.2f" % sum) if sum > 0 %></td>
               <% end -%>
               <td class="hours"><%= html_hours("%.2f" % total) if total > 0 %></td>
               </tr>
             </tbody>
             </table>
             <p class="other-formats">
             <%= l(:label_export_to) %>
             <span><%= link_to 'CSV', params.merge({:format => 'csv'}), :class => 'csv' %></span>
             </p>
             <% end %>
             <% end %>
             <% html_title l(:label_spent_time), l(:label_report) %>

config/routes.rb +1 -1

             ActionController::Routing::Routes.draw do |map|
               # Add your own custom routes here.
               # The priority is based upon order of creation: first created -> highest priority.
               # Here's a sample route:
               # map.connect 'products/:id', :controller => 'catalog', :action => 'view'
               # Keep in mind you can assign values other than :controller and :action
               map.home '', :controller => 'welcome'
               map.signin 'login', :controller => 'account', :action => 'login'
               map.signout 'logout', :controller => 'account', :action => 'logout'
               map.connect 'wiki/:id/:page/:action', :controller => 'wiki', :page => nil
               map.connect 'roles/workflow/:id/:role_id/:tracker_id', :controller => 'roles', :action => 'workflow'
               map.connect 'help/:ctrl/:page', :controller => 'help'
               #map.connect ':controller/:action/:id/:sort_key/:sort_order'
               map.connect 'issues/:issue_id/relations/:action/:id', :controller => 'issue_relations'
               map.connect 'projects/:project_id/issues/:action', :controller => 'issues'
               map.connect 'projects/:project_id/news/:action', :controller => 'news'
               map.connect 'projects/:project_id/documents/:action', :controller => 'documents'
               map.connect 'projects/:project_id/boards/:action/:id', :controller => 'boards'
-              map.connect 'projects/:project_id/timelog/:action/:id', :controller => 'timelog'
+              map.connect 'projects/:project_id/timelog/:action/:id', :controller => 'timelog', :project_id => /.+/
               map.connect 'boards/:board_id/topics/:action/:id', :controller => 'messages'
               map.with_options :controller => 'repositories' do |omap|
                 omap.repositories_show 'repositories/browse/:id/*path', :action => 'browse'
                 omap.repositories_changes 'repositories/changes/:id/*path', :action => 'changes'
                 omap.repositories_diff 'repositories/diff/:id/*path', :action => 'diff'
                 omap.repositories_entry 'repositories/entry/:id/*path', :action => 'entry'
                 omap.repositories_entry 'repositories/annotate/:id/*path', :action => 'annotate'
                 omap.repositories_revision 'repositories/revision/:id/:rev', :action => 'revision'
               end
               map.connect 'attachments/:id', :controller => 'attachments', :action => 'show', :id => /\d+/
               map.connect 'attachments/:id/:filename', :controller => 'attachments', :action => 'show', :id => /\d+/, :filename => /.*/
               map.connect 'attachments/download/:id/:filename', :controller => 'attachments', :action => 'download', :id => /\d+/, :filename => /.*/
               # Allow downloading Web Service WSDL as a file with an extension
               # instead of a file named 'wsdl'
               map.connect ':controller/service.wsdl', :action => 'wsdl'
               # Install the default route as the lowest priority.
               map.connect ':controller/:action/:id'
             end

test/functional/timelog_controller_test.rb +52 -2

             # 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 'timelog_controller'
             # Re-raise errors caught by the controller.
             class TimelogController; def rescue_action(e) raise e end; end
             class TimelogControllerTest < Test::Unit::TestCase
               fixtures :projects, :enabled_modules, :roles, :members, :issues, :time_entries, :users, :trackers, :enumerations, :issue_statuses, :custom_fields, :custom_values
               def setup
                 @controller = TimelogController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
               end
               def test_get_edit
                 @request.session[:user_id] = 3
                 get :edit, :project_id => 1
                 assert_response :success
                 assert_template 'edit'
                 # Default activity selected
                 assert_tag :tag => 'option', :attributes => { :selected => 'selected' },
                                              :content => 'Development'
               end
               def test_post_edit
                 @request.session[:user_id] = 3
                 post :edit, :project_id => 1,
                             :time_entry => {:comments => 'Some work on TimelogControllerTest',
                                             # Not the default activity
                                             :activity_id => '11',
                                             :spent_on => '2008-03-14',
                                             :issue_id => '1',
                                             :hours => '7.3'}
                 assert_redirected_to 'projects/ecookbook/timelog/details'
                 i = Issue.find(1)
                 t = TimeEntry.find_by_comments('Some work on TimelogControllerTest')
                 assert_not_nil t
                 assert_equal 11, t.activity_id
                 assert_equal 7.3, t.hours
                 assert_equal 3, t.user_id
                 assert_equal i, t.issue
                 assert_equal i.project, t.project
               end
               def test_update
                 entry = TimeEntry.find(1)
                 assert_equal 1, entry.issue_id
                 assert_equal 2, entry.user_id
                 @request.session[:user_id] = 1
                 post :edit, :id => 1,
                             :time_entry => {:issue_id => '2',
                                             :hours => '8'}
                 assert_redirected_to 'projects/ecookbook/timelog/details'
                 entry.reload
                 assert_equal 8, entry.hours
                 assert_equal 2, entry.issue_id
                 assert_equal 2, entry.user_id
               end
-              def destroy
+              def test_destroy
                 @request.session[:user_id] = 2
                 post :destroy, :id => 1
                 assert_redirected_to 'projects/ecookbook/timelog/details'
                 assert_nil TimeEntry.find_by_id(1)
               end
               def test_report_no_criteria
                 get :report, :project_id => 1
                 assert_response :success
                 assert_template 'report'
               end
+              def test_report_all_projects
+                get :report
+                assert_response :success
+                assert_template 'report'
+              end
+              def test_report_all_projects_denied
+                r = Role.anonymous
+                r.permissions.delete(:view_time_entries)
+                r.permissions_will_change!
+                r.save
+                get :report
+                assert_redirected_to '/account/login'
+              end
+              def test_report_all_projects_one_criteria
+                get :report, :columns => 'week', :from => "2007-04-01", :to => "2007-04-30", :criterias => ['project']
+                assert_response :success
+                assert_template 'report'
+                assert_not_nil assigns(:total_hours)
+                assert_equal "8.65", "%.2f" % assigns(:total_hours)
+              end
               def test_report_all_time
                 get :report, :project_id => 1, :criterias => ['project', 'issue']
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "162.90", "%.2f" % assigns(:total_hours)
               end
               def test_report_all_time_by_day
                 get :report, :project_id => 1, :criterias => ['project', 'issue'], :columns => 'day'
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "162.90", "%.2f" % assigns(:total_hours)
                 assert_tag :tag => 'th', :content => '2007-03-12'
               end
               def test_report_one_criteria
                 get :report, :project_id => 1, :columns => 'week', :from => "2007-04-01", :to => "2007-04-30", :criterias => ['project']
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "8.65", "%.2f" % assigns(:total_hours)
               end
               def test_report_two_criterias
                 get :report, :project_id => 1, :columns => 'month', :from => "2007-01-01", :to => "2007-12-31", :criterias => ["member", "activity"]
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "162.90", "%.2f" % assigns(:total_hours)
               end
               def test_report_custom_field_criteria
                 get :report, :project_id => 1, :criterias => ['project', 'cf_1']
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_not_nil assigns(:criterias)
                 assert_equal 2, assigns(:criterias).size
                 assert_equal "162.90", "%.2f" % assigns(:total_hours)
                 # Custom field column
                 assert_tag :tag => 'th', :content => 'Database'
                 # Custom field row
                 assert_tag :tag => 'td', :content => 'MySQL',
                                          :sibling => { :tag => 'td', :attributes => { :class => 'hours' },
                                                                      :child => { :tag => 'span', :attributes => { :class => 'hours hours-int' },
                                                                                                  :content => '1' }}
               end
               def test_report_one_criteria_no_result
                 get :report, :project_id => 1, :columns => 'week', :from => "1998-04-01", :to => "1998-04-30", :criterias => ['project']
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "0.00", "%.2f" % assigns(:total_hours)
               end
+              def test_report_all_projects_csv_export
+                get :report, :columns => 'month', :from => "2007-01-01", :to => "2007-06-30", :criterias => ["project", "member", "activity"], :format => "csv"
+                assert_response :success
+                assert_equal 'text/csv', @response.content_type
+                lines = @response.body.chomp.split("\n")
+                # Headers
+                assert_equal 'Project,Member,Activity,2007-1,2007-2,2007-3,2007-4,2007-5,2007-6,Total', lines.first
+                # Total row
+                assert_equal 'Total,"","","","",154.25,8.65,"","",162.90', lines.last
+              end
               def test_report_csv_export
                 get :report, :project_id => 1, :columns => 'month', :from => "2007-01-01", :to => "2007-06-30", :criterias => ["project", "member", "activity"], :format => "csv"
                 assert_response :success
                 assert_equal 'text/csv', @response.content_type
                 lines = @response.body.chomp.split("\n")
                 # Headers
                 assert_equal 'Project,Member,Activity,2007-1,2007-2,2007-3,2007-4,2007-5,2007-6,Total', lines.first
                 # Total row
                 assert_equal 'Total,"","","","",154.25,8.65,"","",162.90', lines.last
               end
+              def test_details_all_projects
+                get :details
+                assert_response :success
+                assert_template 'details'
+                assert_not_nil assigns(:total_hours)
+                assert_equal "162.90", "%.2f" % assigns(:total_hours)
+              end
               def test_details_at_project_level
                 get :details, :project_id => 1
                 assert_response :success
                 assert_template 'details'
                 assert_not_nil assigns(:entries)
                 assert_equal 4, assigns(:entries).size
                 # project and subproject
                 assert_equal [1, 3], assigns(:entries).collect(&:project_id).uniq.sort
                 assert_not_nil assigns(:total_hours)
                 assert_equal "162.90", "%.2f" % assigns(:total_hours)
                 # display all time by default
                 assert_equal '2007-03-11'.to_date, assigns(:from)
                 assert_equal '2007-04-22'.to_date, assigns(:to)
               end
               def test_details_at_project_level_with_date_range
                 get :details, :project_id => 1, :from => '2007-03-20', :to => '2007-04-30'
                 assert_response :success
                 assert_template 'details'
                 assert_not_nil assigns(:entries)
                 assert_equal 3, assigns(:entries).size
                 assert_not_nil assigns(:total_hours)
                 assert_equal "12.90", "%.2f" % assigns(:total_hours)
                 assert_equal '2007-03-20'.to_date, assigns(:from)
                 assert_equal '2007-04-30'.to_date, assigns(:to)
               end
               def test_details_at_project_level_with_period
                 get :details, :project_id => 1, :period => '7_days'
                 assert_response :success
                 assert_template 'details'
                 assert_not_nil assigns(:entries)
                 assert_not_nil assigns(:total_hours)
                 assert_equal Date.today - 7, assigns(:from)
                 assert_equal Date.today, assigns(:to)
               end
               def test_details_at_issue_level
                 get :details, :issue_id => 1
                 assert_response :success
                 assert_template 'details'
                 assert_not_nil assigns(:entries)
                 assert_equal 2, assigns(:entries).size
                 assert_not_nil assigns(:total_hours)
                 assert_equal 154.25, assigns(:total_hours)
                 # display all time by default
                 assert_equal '2007-03-11'.to_date, assigns(:from)
                 assert_equal '2007-04-22'.to_date, assigns(:to)
               end
               def test_details_atom_feed
                 get :details, :project_id => 1, :format => 'atom'
                 assert_response :success
                 assert_equal 'application/atom+xml', @response.content_type
                 assert_not_nil assigns(:items)
                 assert assigns(:items).first.is_a?(TimeEntry)
               end
+              def test_details_all_projects_csv_export
+                get :details, :format => 'csv'
+                assert_response :success
+                assert_equal 'text/csv', @response.content_type
+                assert @response.body.include?("Date,User,Activity,Project,Issue,Tracker,Subject,Hours,Comment\n")
+                assert @response.body.include?("\n04/21/2007,redMine Admin,Design,eCookbook,3,Bug,Error 281 when updating a recipe,1.0,\"\"\n")
+              end
               def test_details_csv_export
                 get :details, :project_id => 1, :format => 'csv'
                 assert_response :success
                 assert_equal 'text/csv', @response.content_type
                 assert @response.body.include?("Date,User,Activity,Project,Issue,Tracker,Subject,Hours,Comment\n")
                 assert @response.body.include?("\n04/21/2007,redMine Admin,Design,eCookbook,3,Bug,Error 281 when updating a recipe,1.0,\"\"\n")
               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