jro_apps/redmine Commit - r673:404bfce44691

Added a cross-project issue list. It displays the issues of all the projects visible by the user....

Jean-Philippe Lang -

r673:404bfce44691

parent child

Context file:

r673:404bfce44691

Collapse all files

app/views/issues/index.rhtml created 644 +55 0

@@ -0,0 +1,55
	1	<h2><%=l(:label_issue_plural)%></h2>
	2
	3	<% form_tag({}, :id => 'query_form') do %>
	4	<%= render :partial => 'queries/filters', :locals => {:query => @query} %>
	5	<% end %>
	6	<div class="contextual">
	7	<%= link_to_remote l(:button_apply),
	8	{ :url => { :set_filter => 1 },
	9	:update => "content",
	10	:with => "Form.serialize('query_form')"
	11	}, :class => 'icon icon-edit' %>
	12
	13	<%= link_to_remote l(:button_clear),
	14	{ :url => { :set_filter => 1 },
	15	:update => "content",
	16	}, :class => 'icon icon-reload' %>
	17	</div>
	18	<br />
	19
	20	<%= error_messages_for 'query' %>
	21	<% if @query.valid? %>
	22	<% if @issues.empty? %>
	23	<p><i><%= l(:label_no_data) %></i></p>
	24	<% else %>
	25
	26	<table class="list">
	27	<thead><tr>
	28	<%= sort_header_tag("#{Issue.table_name}.id", :caption => '#') %>
	29	<%= sort_header_tag("#{Project.table_name}.name", :caption => l(:field_project)) %>
	30	<%= sort_header_tag("#{Issue.table_name}.tracker_id", :caption => l(:field_tracker)) %>
	31	<%= sort_header_tag("#{IssueStatus.table_name}.name", :caption => l(:field_status)) %>
	32	<%= sort_header_tag("#{Issue.table_name}.priority_id", :caption => l(:field_priority)) %>
	33	<th><%=l(:field_subject)%></th>
	34	<%= sort_header_tag("#{User.table_name}.lastname", :caption => l(:field_assigned_to)) %>
	35	<%= sort_header_tag("#{Issue.table_name}.updated_on", :caption => l(:field_updated_on)) %>
	36	</tr></thead>
	37	<tbody>
	38	<% for issue in @issues %>
	39	<tr class="<%= cycle("odd", "even") %>">
	40	<td align="center" valign="top"><%= link_to issue.id, :controller => 'issues', :action => 'show', :id => issue %></td>
	41	<td align="center" valign="top" nowrap><%=h issue.project.name %></td>
	42	<td align="center" valign="top" nowrap><%= issue.tracker.name %></td>
	43	<td valign="top"nowrap><div class="square" style="background:#<%= issue.status.html_color %>;"></div> <%= issue.status.name %></td>
	44	<td align="center" valign="top"><%= issue.priority.name %></td>
	45	<td><%= link_to h(issue.subject), :controller => 'issues', :action => 'show', :id => issue %></td>
	46	<td align="center" valign="top" nowrap><%= issue.assigned_to.name if issue.assigned_to %></td>
	47	<td align="center" valign="top" nowrap><%= format_time(issue.updated_on) %></td>
	48	</tr>
	49	<% end %>
	50	</tbody>
	51	</table>
	52	<p><%= pagination_links_full @issue_pages %>
	53	[ <%= @issue_pages.current.first_item %> - <%= @issue_pages.current.last_item %> / <%= @issue_count %> ]</p>
	54	<% end %>
	55	<% end %>

app/controllers/issues_controller.rb +40 -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.
             class IssuesController < ApplicationController
               layout 'base', :except => :export_pdf
-              before_filter :find_project, :authorize
+              before_filter :find_project, :authorize, :except => :index
               cache_sweeper :issue_sweeper, :only => [ :edit, :change_status, :destroy ]
               helper :projects
               include ProjectsHelper
               helper :custom_fields
               include CustomFieldsHelper
               helper :ifpdf
               include IfpdfHelper
               helper :issue_relations
               include IssueRelationsHelper
               helper :watchers
               include WatchersHelper
               helper :attachments
               include AttachmentsHelper
+              helper :queries
+              helper :sort
+              include SortHelper
+              def index
+                sort_init "#{Issue.table_name}.id", "desc"
+                sort_update
+                retrieve_query
+                if @query.valid?
+                  @issue_count = Issue.count(:include => [:status, :project], :conditions => @query.statement)
+                  @issue_pages = Paginator.new self, @issue_count, 25, params['page']
+                  @issues = Issue.find :all, :order => sort_clause,
+                                       :include => [ :assigned_to, :status, :tracker, :project, :priority ],
+                                       :conditions => @query.statement,
+                                       :limit  =>  @issue_pages.items_per_page,
+                                       :offset =>  @issue_pages.current.offset
+                end
+                render :layout => false if request.xhr?
+              end
               def show
                 @status_options = @issue.status.find_new_statuses_allowed_to(logged_in_user.role_for_project(@project), @issue.tracker) if logged_in_user
                 @custom_values = @issue.custom_values.find(:all, :include => :custom_field)
                 @journals = @issue.journals.find(:all, :include => [:user, :details], :order => "#{Journal.table_name}.created_on ASC")
               end
               def export_pdf
                 @custom_values = @issue.custom_values.find(:all, :include => :custom_field)
                 @options_for_rfpdf ||= {}
                 @options_for_rfpdf[:file_name] = "#{@project.name}_#{@issue.id}.pdf"
               end
               def edit
                 @priorities = Enumeration::get_values('IPRI')
                 if request.get?
                   @custom_values = @project.custom_fields_for_issues(@issue.tracker).collect { |x| @issue.custom_values.find_by_custom_field_id(x.id) || CustomValue.new(:custom_field => x, :customized => @issue) }
                 else
                   begin
                     @issue.init_journal(self.logged_in_user)
                     # Retrieve custom fields and values
                     @custom_values = @project.custom_fields_for_issues(@issue.tracker).collect { |x| CustomValue.new(:custom_field => x, :customized => @issue, :value => params["custom_fields"][x.id.to_s]) }
                     @issue.custom_values = @custom_values
                     @issue.attributes = params[:issue]
                     if @issue.save
                       flash[:notice] = l(:notice_successful_update)
                       redirect_to :action => 'show', :id => @issue
                     end
                   rescue ActiveRecord::StaleObjectError
                     # Optimistic locking exception
                     flash[:error] = l(:notice_locking_conflict)
                   end
                 end
               end
               def add_note
                 unless params[:notes].empty?
                   journal = @issue.init_journal(self.logged_in_user, params[:notes])
                   if @issue.save
                     params[:attachments].each { |file|
                       next unless file.size > 0
                       a = Attachment.create(:container => @issue, :file => file, :author => logged_in_user)
                       journal.details << JournalDetail.new(:property => 'attachment',
                                                            :prop_key => a.id,
                                                            :value => a.filename) unless a.new_record?
                     } if params[:attachments] and params[:attachments].is_a? Array
                     flash[:notice] = l(:notice_successful_update)
                     Mailer.deliver_issue_edit(journal) #if Permission.find_by_controller_and_action(params[:controller], params[:action]).mail_enabled?
                     redirect_to :action => 'show', :id => @issue
                     return
                   end
                 end
                 show
                 render :action => 'show'
               end
               def change_status
                 @status_options = @issue.status.find_new_statuses_allowed_to(logged_in_user.role_for_project(@project), @issue.tracker) if logged_in_user
                 @new_status = IssueStatus.find(params[:new_status_id])
                 if params[:confirm]
                   begin
                     journal = @issue.init_journal(self.logged_in_user, params[:notes])
                     @issue.status = @new_status
                     if @issue.update_attributes(params[:issue])
                       # Save attachments
                       params[:attachments].each { |file|
                         next unless file.size > 0
                         a = Attachment.create(:container => @issue, :file => file, :author => logged_in_user)
                         journal.details << JournalDetail.new(:property => 'attachment',
                                                              :prop_key => a.id,
                                                              :value => a.filename) unless a.new_record?
                       } if params[:attachments] and params[:attachments].is_a? Array
                       # Log time
                       if current_role.allowed_to?(:log_time)
                         @time_entry ||= TimeEntry.new(:project => @project, :issue => @issue, :user => logged_in_user, :spent_on => Date.today)
                         @time_entry.attributes = params[:time_entry]
                         @time_entry.save
                       end
                       flash[:notice] = l(:notice_successful_update)
                       Mailer.deliver_issue_edit(journal) #if Permission.find_by_controller_and_action(params[:controller], params[:action]).mail_enabled?
                       redirect_to :action => 'show', :id => @issue
                     end
                   rescue ActiveRecord::StaleObjectError
                     # Optimistic locking exception
                     flash[:error] = l(:notice_locking_conflict)
                   end
                 end
                 @assignable_to = @project.members.find(:all, :include => :user).collect{ |m| m.user }
                 @activities = Enumeration::get_values('ACTI')
               end
               def destroy
                 @issue.destroy
                 redirect_to :controller => 'projects', :action => 'list_issues', :id => @project
               end
               def destroy_attachment
                 a = @issue.attachments.find(params[:attachment_id])
                 a.destroy
                 journal = @issue.init_journal(self.logged_in_user)
                 journal.details << JournalDetail.new(:property => 'attachment',
                                                      :prop_key => a.id,
                                                      :old_value => a.filename)
                 journal.save
                 redirect_to :action => 'show', :id => @issue
               end
             private
               def find_project
                 @issue = Issue.find(params[:id], :include => [:project, :tracker, :status, :author, :priority, :category])
                 @project = @issue.project
                 @html_title = "#{@project.name} - #{@issue.tracker.name} ##{@issue.id}"
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
+              # Retrieve query from session or build a new query
+              def retrieve_query
+                if params[:set_filter] or !session[:query] or session[:query].project_id
+                  # Give it a name, required to be valid
+                  @query = Query.new(:name => "_", :executed_by => logged_in_user)
+                  if params[:fields] and params[:fields].is_a? Array
+                    params[:fields].each do |field|
+                      @query.add_filter(field, params[:operators][field], params[:values][field])
+                    end
+                  else
+                    @query.available_filters.keys.each do |field|
+                      @query.add_short_filter(field, params[field]) if params[field]
+                    end
+                  end
+                  session[:query] = @query
+                else
+                  @query = session[:query]
+                end
+              end
             end

app/models/project.rb +3 -3

             # 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.
             class Project < ActiveRecord::Base
               # Project statuses
               STATUS_ACTIVE     = 1
               STATUS_ARCHIVED   = 9
               has_many :members, :dependent => :delete_all, :include => :user, :conditions => "#{User.table_name}.status=#{User::STATUS_ACTIVE}"
               has_many :users, :through => :members
               has_many :custom_values, :dependent => :delete_all, :as => :customized
               has_many :issues, :dependent => :destroy, :order => "#{Issue.table_name}.created_on DESC", :include => [:status, :tracker]
               has_many :issue_changes, :through => :issues, :source => :journals
               has_many :versions, :dependent => :destroy, :order => "#{Version.table_name}.effective_date DESC, #{Version.table_name}.name DESC"
               has_many :time_entries, :dependent => :delete_all
               has_many :queries, :dependent => :delete_all
               has_many :documents, :dependent => :destroy
               has_many :news, :dependent => :delete_all, :include => :author
               has_many :issue_categories, :dependent => :delete_all, :order => "#{IssueCategory.table_name}.name"
               has_many :boards, :order => "position ASC"
               has_one :repository, :dependent => :destroy
               has_one :wiki, :dependent => :destroy
               has_and_belongs_to_many :custom_fields, :class_name => 'IssueCustomField', :join_table => "#{table_name_prefix}custom_fields_projects#{table_name_suffix}", :association_foreign_key => 'custom_field_id'
               acts_as_tree :order => "name", :counter_cache => true
               attr_protected :status
               validates_presence_of :name, :description, :identifier
               validates_uniqueness_of :name, :identifier
               validates_associated :custom_values, :on => :update
               validates_associated :repository, :wiki
               validates_length_of :name, :maximum => 30
               validates_format_of :name, :with => /^[\w\s\'\-]*$/i
               validates_length_of :description, :maximum => 255
               validates_length_of :identifier, :in => 3..12
               validates_format_of :identifier, :with => /^[a-z0-9\-]*$/
               def identifier=(identifier)
                 super unless identifier_frozen?
               end
               def identifier_frozen?
                 errors[:identifier].nil? && !(new_record? || identifier.blank?)
               end
               def issues_with_subprojects(include_subprojects=false)
                 conditions = nil
                 if include_subprojects && !active_children.empty?
                   ids = [id] + active_children.collect {|c| c.id}
                   conditions = ["#{Issue.table_name}.project_id IN (#{ids.join(',')})"]
                 end
                 conditions ||= ["#{Issue.table_name}.project_id = ?", id]
                 Issue.with_scope :find => { :conditions => conditions } do
                   yield
                 end
               end
               # returns latest created projects
               # non public projects will be returned only if user is a member of those
               def self.latest(user=nil, count=5)
                 find(:all, :limit => count, :conditions => visible_by(user), :order => "created_on DESC")
               end
               def self.visible_by(user=nil)
                 if user && user.admin?
-                  return ["#{Project.table_name}.status=#{Project::STATUS_ACTIVE}"]
+                  return "#{Project.table_name}.status=#{Project::STATUS_ACTIVE}"
                 elsif user && user.memberships.any?
-                  return ["#{Project.table_name}.status=#{Project::STATUS_ACTIVE} AND (#{Project.table_name}.is_public = ? or #{Project.table_name}.id IN (#{user.memberships.collect{|m| m.project_id}.join(',')}))", true]
+                  return "#{Project.table_name}.status=#{Project::STATUS_ACTIVE} AND (#{Project.table_name}.is_public = #{connection.quoted_true} or #{Project.table_name}.id IN (#{user.memberships.collect{|m| m.project_id}.join(',')}))"
                 else
-                  return ["#{Project.table_name}.status=#{Project::STATUS_ACTIVE} AND #{Project.table_name}.is_public = ?", true]
+                  return "#{Project.table_name}.status=#{Project::STATUS_ACTIVE} AND #{Project.table_name}.is_public = #{connection.quoted_true}"
                 end
               end
               def active?
                 self.status == STATUS_ACTIVE
               end
               def archive
                 # Archive subprojects if any
                 children.each do |subproject|
                   subproject.archive
                 end
                 update_attribute :status, STATUS_ARCHIVED
               end
               def unarchive
                 return false if parent && !parent.active?
                 update_attribute :status, STATUS_ACTIVE
               end
               def active_children
                 children.select {|child| child.active?}
               end
               # Returns an array of all custom fields enabled for project issues
               # (explictly associated custom fields and custom fields enabled for all projects)
               def custom_fields_for_issues(tracker)
                 all_custom_fields.select {|c| tracker.custom_fields.include? c }
               end
               def all_custom_fields
                 @all_custom_fields ||= (IssueCustomField.for_all + custom_fields).uniq
               end
             protected
               def validate
                 errors.add(parent_id, " must be a root project") if parent and parent.parent
                 errors.add_to_base("A project with subprojects can't be a subproject") if parent and children.size > 0
               end
             end

app/models/query.rb +17 -8

             # 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 Query < ActiveRecord::Base
               belongs_to :project
               belongs_to :user
               serialize :filters
               attr_protected :project, :user
               attr_accessor :executed_by
               validates_presence_of :name, :on => :save
               validates_length_of :name, :maximum => 255
               @@operators = { "="   => :label_equals,
                               "!"   => :label_not_equals,
                               "o"   => :label_open_issues,
                               "c"   => :label_closed_issues,
                               "!*"  => :label_none,
                               "*"   => :label_all,
                               "<t+" => :label_in_less_than,
                               ">t+" => :label_in_more_than,
                               "t+"  => :label_in,
                               "t"   => :label_today,
                               ">t-" => :label_less_than_ago,
                               "<t-" => :label_more_than_ago,
                               "t-"  => :label_ago,
                               "~"   => :label_contains,
                               "!~"  => :label_not_contains }
               cattr_reader :operators
               @@operators_by_filter_type = { :list => [ "=", "!" ],
                                              :list_status => [ "o", "=", "!", "c", "*" ],
                                              :list_optional => [ "=", "!", "!*", "*" ],
                                              :list_one_or_more => [ "*", "=" ],
                                              :date => [ "<t+", ">t+", "t+", "t", ">t-", "<t-", "t-" ],
                                              :date_past => [ ">t-", "<t-", "t-", "t" ],
                                              :string => [ "=", "~", "!", "!~" ],
                                              :text => [  "~", "!~" ] }
               cattr_reader :operators_by_filter_type
               def initialize(attributes = nil)
                 super attributes
                 self.filters ||= { 'status_id' => {:operator => "o", :values => [""]} }
               end
               def executed_by=(user)
                 @executed_by = user
                 set_language_if_valid(user.language) if user
               end
               def validate
                 filters.each_key do |field|
                   errors.add label_for(field), :activerecord_error_blank unless
                       # filter requires one or more values
                       (values_for(field) and !values_for(field).first.empty?) or
                       # filter doesn't require any value
                       ["o", "c", "!*", "*", "t"].include? operator_for(field)
                 end if filters
               end
               def editable_by?(user)
                 return false unless user
                 return true if !is_public && self.user_id == user.id
                 is_public && user.allowed_to?(:manage_pulic_queries, project)
               end
               def available_filters
                 return @available_filters if @available_filters
                 @available_filters = { "status_id" => { :type => :list_status, :order => 1, :values => IssueStatus.find(:all, :order => 'position').collect{|s| [s.name, s.id.to_s] } },
                                        "tracker_id" => { :type => :list, :order => 2, :values => Tracker.find(:all, :order => 'position').collect{|s| [s.name, s.id.to_s] } },
                                        "priority_id" => { :type => :list, :order => 3, :values => Enumeration.find(:all, :conditions => ['opt=?','IPRI']).collect{|s| [s.name, s.id.to_s] } },
                                        "subject" => { :type => :text, :order => 8 },
                                        "created_on" => { :type => :date_past, :order => 9 },
                                        "updated_on" => { :type => :date_past, :order => 10 },
                                        "start_date" => { :type => :date, :order => 11 },
                                        "due_date" => { :type => :date, :order => 12 } }
-                unless project.nil?
-                  # project specific filters
                 user_values = []
+                if project
+                  user_values += project.users.collect{|s| [s.name, s.id.to_s] }
+                elsif executed_by
                   user_values << ["<< #{l(:label_me)} >>", "me"] if executed_by
-                  user_values += @project.users.collect{|s| [s.name, s.id.to_s] }
+                  # members of the user's projects
+                  user_values += executed_by.projects.collect(&:users).flatten.uniq.sort.collect{|s| [s.name, s.id.to_s] }
+                end
+                @available_filters["assigned_to_id"] = { :type => :list_optional, :order => 4, :values => user_values } unless user_values.empty?
+                @available_filters["author_id"] = { :type => :list, :order => 5, :values => user_values } unless user_values.empty?
-                  @available_filters["assigned_to_id"] = { :type => :list_optional, :order => 4, :values => user_values }
+                if project
-                  @available_filters["author_id"] = { :type => :list, :order => 5, :values => user_values }
+                  # project specific filters
                   @available_filters["category_id"] = { :type => :list_optional, :order => 6, :values => @project.issue_categories.collect{|s| [s.name, s.id.to_s] } }
                   @available_filters["fixed_version_id"] = { :type => :list_optional, :order => 7, :values => @project.versions.sort.collect{|s| [s.name, s.id.to_s] } }
                   unless @project.active_children.empty?
                     @available_filters["subproject_id"] = { :type => :list_one_or_more, :order => 13, :values => @project.active_children.collect{|s| [s.name, s.id.to_s] } }
                   end
                   @project.all_custom_fields.select(&:is_filter?).each do |field|
                     case field.field_format
                     when "string", "int"
                       options = { :type => :string, :order => 20 }
                     when "text"
                       options = { :type => :text, :order => 20 }
                     when "list"
                       options = { :type => :list_optional, :values => field.possible_values, :order => 20}
                     when "date"
                       options = { :type => :date, :order => 20 }
                     when "bool"
                       options = { :type => :list, :values => [[l(:general_text_yes), "1"], [l(:general_text_no), "0"]], :order => 20 }
                     end
                     @available_filters["cf_#{field.id}"] = options.merge({ :name => field.name })
                   end
                   # remove category filter if no category defined
                   @available_filters.delete "category_id" if @available_filters["category_id"][:values].empty?
                 end
                 @available_filters
               end
               def add_filter(field, operator, values)
                 # values must be an array
                 return unless values and values.is_a? Array # and !values.first.empty?
                 # check if field is defined as an available filter
                 if available_filters.has_key? field
                   filter_options = available_filters[field]
                   # check if operator is allowed for that filter
                   #if @@operators_by_filter_type[filter_options[:type]].include? operator
                   #  allowed_values = values & ([""] + (filter_options[:values] || []).collect {|val| val[1]})
                   #  filters[field] = {:operator => operator, :values => allowed_values } if (allowed_values.first and !allowed_values.first.empty?) or ["o", "c", "!*", "*", "t"].include? operator
                   #end
                   filters[field] = {:operator => operator, :values => values }
                 end
               end
               def add_short_filter(field, expression)
                 return unless expression
                 parms = expression.scan(/^(o|c|\!|\*)?(.*)$/).first
                 add_filter field, (parms[0] || "="), [parms[1] || ""]
               end
               def has_filter?(field)
                 filters and filters[field]
               end
               def operator_for(field)
                 has_filter?(field) ? filters[field][:operator] : nil
               end
               def values_for(field)
                 has_filter?(field) ? filters[field][:values] : nil
               end
               def label_for(field)
                 label = @available_filters[field][:name] if @available_filters.has_key?(field)
                 label ||= field.gsub(/\_id$/, "")
               end
               def statement
                 # project/subprojects clause
                 clause = ''
-                if has_filter?("subproject_id")
+                if project && has_filter?("subproject_id")
                   subproject_ids = []
                   if operator_for("subproject_id") == "="
                     subproject_ids = values_for("subproject_id").each(&:to_i)
                   else
                     subproject_ids = project.active_children.collect{|p| p.id}
                   end
                   clause << "#{Issue.table_name}.project_id IN (%d,%s)" % [project.id, subproject_ids.join(",")] if project
+                elsif project
+                  clause << "#{Issue.table_name}.project_id=%d" % project.id
                 else
-                  clause << "#{Issue.table_name}.project_id=%d" % project.id if project
+                  clause << Project.visible_by(executed_by)
                 end
                 # filters clauses
                 filters_clauses = []
                 filters.each_key do |field|
                   next if field == "subproject_id"
                   v = values_for(field).clone
                   next unless v and !v.empty?
                   sql = ''
                   if field =~ /^cf_(\d+)$/
                     # custom field
                     db_table = CustomValue.table_name
                     db_field = 'value'
                     sql << "#{Issue.table_name}.id IN (SELECT #{db_table}.customized_id FROM #{db_table} where #{db_table}.customized_type='Issue' AND #{db_table}.customized_id=#{Issue.table_name}.id AND #{db_table}.custom_field_id=#{$1} AND "
                   else
                     # regular field
                     db_table = Issue.table_name
                     db_field = field
                     sql << '('
                   end
                   # "me" value subsitution
                   if %w(assigned_to_id author_id).include?(field)
                     v.push(executed_by ? executed_by.id.to_s : "0") if v.delete("me")
                   end
                   case operator_for field
                   when "="
                     sql = sql + "#{db_table}.#{db_field} IN (" + v.collect{|val| "'#{connection.quote_string(val)}'"}.join(",") + ")"
                   when "!"
                     sql = sql + "#{db_table}.#{db_field} NOT IN (" + v.collect{|val| "'#{connection.quote_string(val)}'"}.join(",") + ")"
                   when "!*"
                     sql = sql + "#{db_table}.#{db_field} IS NULL"
                   when "*"
                     sql = sql + "#{db_table}.#{db_field} IS NOT NULL"
                   when "o"
                     sql = sql + "#{IssueStatus.table_name}.is_closed=#{connection.quoted_false}" if field == "status_id"
                   when "c"
                     sql = sql + "#{IssueStatus.table_name}.is_closed=#{connection.quoted_true}" if field == "status_id"
                   when ">t-"
                     sql = sql + "#{db_table}.#{db_field} BETWEEN '%s' AND '%s'" % [connection.quoted_date((Date.today - v.first.to_i).to_time), connection.quoted_date((Date.today + 1).to_time)]
                   when "<t-"
                     sql = sql + "#{db_table}.#{db_field} <= '%s'" % connection.quoted_date((Date.today - v.first.to_i).to_time)
                   when "t-"
                     sql = sql + "#{db_table}.#{db_field} BETWEEN '%s' AND '%s'" % [connection.quoted_date((Date.today - v.first.to_i).to_time), connection.quoted_date((Date.today - v.first.to_i + 1).to_time)]
                   when ">t+"
                     sql = sql + "#{db_table}.#{db_field} >= '%s'" % connection.quoted_date((Date.today + v.first.to_i).to_time)
                   when "<t+"
                     sql = sql + "#{db_table}.#{db_field} BETWEEN '%s' AND '%s'" % [connection.quoted_date(Date.today.to_time), connection.quoted_date((Date.today + v.first.to_i + 1).to_time)]
                   when "t+"
                     sql = sql + "#{db_table}.#{db_field} BETWEEN '%s' AND '%s'" % [connection.quoted_date((Date.today + v.first.to_i).to_time), connection.quoted_date((Date.today + v.first.to_i + 1).to_time)]
                   when "t"
                     sql = sql + "#{db_table}.#{db_field} BETWEEN '%s' AND '%s'" % [connection.quoted_date(Date.today.to_time), connection.quoted_date((Date.today+1).to_time)]
                   when "~"
                     sql = sql + "#{db_table}.#{db_field} LIKE '%#{connection.quote_string(v.first)}%'"
                   when "!~"
                     sql = sql + "#{db_table}.#{db_field} NOT LIKE '%#{connection.quote_string(v.first)}%'"
                   end
                   sql << ')'
                   filters_clauses << sql
                 end if filters and valid?
-                clause << (' AND ' + filters_clauses.join(' AND ')) unless filters_clauses.empty?
+                clause << ' AND ' unless clause.empty?
+                clause << filters_clauses.join(' AND ') unless filters_clauses.empty?
                 clause
               end
             end

app/views/my/blocks/_issuesassignedtome.rhtml +2 -2

             <h3><%=l(:label_assigned_to_me_issues)%></h3>
             <% assigned_issues = Issue.find(:all,
                                             :conditions => ["assigned_to_id=? AND #{IssueStatus.table_name}.is_closed=? AND #{Project.table_name}.status=#{Project::STATUS_ACTIVE}", user.id, false],
                                             :limit => 10,
                                             :include => [ :status, :project, :tracker ],
-                                            :order => "#{Issue.table_name}.updated_on DESC") %>
+                                            :order => "#{Issue.table_name}.priority_id DESC, #{Issue.table_name}.updated_on DESC") %>
             <%= render :partial => 'issues/list_simple', :locals => { :issues => assigned_issues } %>
             <% if assigned_issues.length > 0 %>
-            <p><%=lwr(:label_last_updates, assigned_issues.length)%></p>
+            <p class="small"><%= link_to l(:label_issue_view_all), :controller => 'issues', :action => 'index', :set_filter => 1, :assigned_to_id => 'me' %></p>
             <% end %>

app/views/my/blocks/_issuesreportedbyme.rhtml +1 -1

             <h3><%=l(:label_reported_issues)%></h3>
             <% reported_issues = Issue.find(:all,
                                             :conditions => ["author_id=? AND #{Project.table_name}.status=#{Project::STATUS_ACTIVE}", user.id],
                                             :limit => 10,
                                             :include => [ :status, :project, :tracker ],
                                             :order => "#{Issue.table_name}.updated_on DESC") %>
             <%= render :partial => 'issues/list_simple', :locals => { :issues => reported_issues } %>
             <% if reported_issues.length > 0 %>
-            <p><%=lwr(:label_last_updates, reported_issues.length)%></p>
+            <p class="small"><%= link_to l(:label_issue_view_all), :controller => 'issues', :action => 'index', :set_filter => 1, :author_id => 'me' %></p>
             <% end %>

test/functional/my_controller_test.rb +3 -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 'my_controller'
             # Re-raise errors caught by the controller.
             class MyController; def rescue_action(e) raise e end; end
             class MyControllerTest < Test::Unit::TestCase
+              fixtures :users
               def setup
                 @controller = MyController.new
                 @request    = ActionController::TestRequest.new
                 @request.session[:user_id] = 2
                 @response   = ActionController::TestResponse.new
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'page'
               end
               def test_page
                 get :page
                 assert_response :success
                 assert_template 'page'
               end
               def test_get_account
                 get :account
                 assert_response :success
                 assert_template 'account'
                 assert_equal User.find(2), assigns(:user)
               end
               def test_update_account
                 post :account, :user => {:firstname => "Joe", :login => "root", :admin => 1}
-                assert_response :success
+                assert_redirected_to 'my/account'
-                assert_template 'account'
                 user = User.find(2)
                 assert_equal user, assigns(:user)
                 assert_equal "Joe", user.firstname
                 assert_equal "jsmith", user.login
                 assert !user.admin?
               end
               def test_change_password
                 get :account
                 assert_response :success
                 assert_template 'account'
                 # non matching password confirmation
                 post :change_password, :password => 'jsmith',
                                        :new_password => 'hello',
                                        :new_password_confirmation => 'hello2'
                 assert_response :success
                 assert_template 'account'
                 assert_tag :tag => "div", :attributes => { :class => "errorExplanation" }
                 # wrong password
                 post :change_password, :password => 'wrongpassword',
                                        :new_password => 'hello',
                                        :new_password_confirmation => 'hello'
                 assert_redirected_to 'my/account'
                 assert_equal 'Wrong password', flash[:error]
                 # good password
                 post :change_password, :password => 'jsmith',
                                        :new_password => 'hello',
                                        :new_password_confirmation => 'hello'
                 assert_redirected_to 'my/account'
                 assert User.try_to_login('jsmith', 'hello')
               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