jro_apps/redmine Commit - r10737:ab066317e62b

Adds STI to Query model. Issue queries are now IssueQuery instances....

Jean-Philippe Lang -

r10737:ab066317e62b

parent child

Context file:

r10737:ab066317e62b

Collapse all files

The requested changes are too big and content was truncated. Show full diff

app/models/issue_query.rb created 644 +321 0

@@ -0,0 +1,321
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2012 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	class IssueQuery < Query
	19
	20	self.available_columns = [
	21	QueryColumn.new(:project, :sortable => "#{Project.table_name}.name", :groupable => true),
	22	QueryColumn.new(:tracker, :sortable => "#{Tracker.table_name}.position", :groupable => true),
	23	QueryColumn.new(:parent, :sortable => ["#{Issue.table_name}.root_id", "#{Issue.table_name}.lft ASC"], :default_order => 'desc', :caption => :field_parent_issue),
	24	QueryColumn.new(:status, :sortable => "#{IssueStatus.table_name}.position", :groupable => true),
	25	QueryColumn.new(:priority, :sortable => "#{IssuePriority.table_name}.position", :default_order => 'desc', :groupable => true),
	26	QueryColumn.new(:subject, :sortable => "#{Issue.table_name}.subject"),
	27	QueryColumn.new(:author, :sortable => lambda {User.fields_for_order_statement("authors")}, :groupable => true),
	28	QueryColumn.new(:assigned_to, :sortable => lambda {User.fields_for_order_statement}, :groupable => true),
	29	QueryColumn.new(:updated_on, :sortable => "#{Issue.table_name}.updated_on", :default_order => 'desc'),
	30	QueryColumn.new(:category, :sortable => "#{IssueCategory.table_name}.name", :groupable => true),
	31	QueryColumn.new(:fixed_version, :sortable => lambda {Version.fields_for_order_statement}, :groupable => true),
	32	QueryColumn.new(:start_date, :sortable => "#{Issue.table_name}.start_date"),
	33	QueryColumn.new(:due_date, :sortable => "#{Issue.table_name}.due_date"),
	34	QueryColumn.new(:estimated_hours, :sortable => "#{Issue.table_name}.estimated_hours"),
	35	QueryColumn.new(:done_ratio, :sortable => "#{Issue.table_name}.done_ratio", :groupable => true),
	36	QueryColumn.new(:created_on, :sortable => "#{Issue.table_name}.created_on", :default_order => 'desc'),
	37	QueryColumn.new(:relations, :caption => :label_related_issues),
	38	QueryColumn.new(:description, :inline => false)
	39	]
	40
	41	scope :visible, lambda {\|*args\|
	42	user = args.shift \|\| User.current
	43	base = Project.allowed_to_condition(user, :view_issues, *args)
	44	user_id = user.logged? ? user.id : 0
	45
	46	includes(:project).where("(#{table_name}.project_id IS NULL OR (#{base})) AND (#{table_name}.is_public = ? OR #{table_name}.user_id = ?)", true, user_id)
	47	}
	48
	49	def initialize(attributes=nil, *args)
	50	super attributes
	51	self.filters \|\|= { 'status_id' => {:operator => "o", :values => [""]} }
	52	end
	53
	54	# Returns true if the query is visible to +user+ or the current user.
	55	def visible?(user=User.current)
	56	(project.nil? \|\| user.allowed_to?(:view_issues, project)) && (self.is_public? \|\| self.user_id == user.id)
	57	end
	58
	59	def available_filters
	60	return @available_filters if @available_filters
	61	@available_filters = {
	62	"status_id" => {
	63	:type => :list_status, :order => 0,
	64	:values => IssueStatus.sorted.all.collect{\|s\| [s.name, s.id.to_s] }
	65	},
	66	"tracker_id" => {
	67	:type => :list, :order => 2, :values => trackers.collect{\|s\| [s.name, s.id.to_s] }
	68	},
	69	"priority_id" => {
	70	:type => :list, :order => 3, :values => IssuePriority.all.collect{\|s\| [s.name, s.id.to_s] }
	71	},
	72	"subject" => { :type => :text, :order => 8 },
	73	"created_on" => { :type => :date_past, :order => 9 },
	74	"updated_on" => { :type => :date_past, :order => 10 },
	75	"start_date" => { :type => :date, :order => 11 },
	76	"due_date" => { :type => :date, :order => 12 },
	77	"estimated_hours" => { :type => :float, :order => 13 },
	78	"done_ratio" => { :type => :integer, :order => 14 }
	79	}
	80	IssueRelation::TYPES.each do \|relation_type, options\|
	81	@available_filters[relation_type] = {
	82	:type => :relation, :order => @available_filters.size + 100,
	83	:label => options[:name]
	84	}
	85	end
	86	principals = []
	87	if project
	88	principals += project.principals.sort
	89	unless project.leaf?
	90	subprojects = project.descendants.visible.all
	91	if subprojects.any?
	92	@available_filters["subproject_id"] = {
	93	:type => :list_subprojects, :order => 13,
	94	:values => subprojects.collect{\|s\| [s.name, s.id.to_s] }
	95	}
	96	principals += Principal.member_of(subprojects)
	97	end
	98	end
	99	else
	100	if all_projects.any?
	101	# members of visible projects
	102	principals += Principal.member_of(all_projects)
	103	# project filter
	104	project_values = []
	105	if User.current.logged? && User.current.memberships.any?
	106	project_values << ["<< #{l(:label_my_projects).downcase} >>", "mine"]
	107	end
	108	project_values += all_projects_values
	109	@available_filters["project_id"] = {
	110	:type => :list, :order => 1, :values => project_values
	111	} unless project_values.empty?
	112	end
	113	end
	114	principals.uniq!
	115	principals.sort!
	116	users = principals.select {\|p\| p.is_a?(User)}
	117
	118	assigned_to_values = []
	119	assigned_to_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?
	120	assigned_to_values += (Setting.issue_group_assignment? ?
	121	principals : users).collect{\|s\| [s.name, s.id.to_s] }
	122	@available_filters["assigned_to_id"] = {
	123	:type => :list_optional, :order => 4, :values => assigned_to_values
	124	} unless assigned_to_values.empty?
	125
	126	author_values = []
	127	author_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?
	128	author_values += users.collect{\|s\| [s.name, s.id.to_s] }
	129	@available_filters["author_id"] = {
	130	:type => :list, :order => 5, :values => author_values
	131	} unless author_values.empty?
	132
	133	group_values = Group.all.collect {\|g\| [g.name, g.id.to_s] }
	134	@available_filters["member_of_group"] = {
	135	:type => :list_optional, :order => 6, :values => group_values
	136	} unless group_values.empty?
	137
	138	role_values = Role.givable.collect {\|r\| [r.name, r.id.to_s] }
	139	@available_filters["assigned_to_role"] = {
	140	:type => :list_optional, :order => 7, :values => role_values
	141	} unless role_values.empty?
	142
	143	if User.current.logged?
	144	@available_filters["watcher_id"] = {
	145	:type => :list, :order => 15, :values => [["<< #{l(:label_me)} >>", "me"]]
	146	}
	147	end
	148
	149	if project
	150	# project specific filters
	151	categories = project.issue_categories.all
	152	unless categories.empty?
	153	@available_filters["category_id"] = {
	154	:type => :list_optional, :order => 6,
	155	:values => categories.collect{\|s\| [s.name, s.id.to_s] }
	156	}
	157	end
	158	versions = project.shared_versions.all
	159	unless versions.empty?
	160	@available_filters["fixed_version_id"] = {
	161	:type => :list_optional, :order => 7,
	162	:values => versions.sort.collect{\|s\| ["#{s.project.name} - #{s.name}", s.id.to_s] }
	163	}
	164	end
	165	add_custom_fields_filters(project.all_issue_custom_fields)
	166	else
	167	# global filters for cross project issue list
	168	system_shared_versions = Version.visible.find_all_by_sharing('system')
	169	unless system_shared_versions.empty?
	170	@available_filters["fixed_version_id"] = {
	171	:type => :list_optional, :order => 7,
	172	:values => system_shared_versions.sort.collect{\|s\|
	173	["#{s.project.name} - #{s.name}", s.id.to_s]
	174	}
	175	}
	176	end
	177	add_custom_fields_filters(IssueCustomField.where(:is_filter => true, :is_for_all => true).all)
	178	end
	179	add_associations_custom_fields_filters :project, :author, :assigned_to, :fixed_version
	180	if User.current.allowed_to?(:set_issues_private, nil, :global => true) \|\|
	181	User.current.allowed_to?(:set_own_issues_private, nil, :global => true)
	182	@available_filters["is_private"] = {
	183	:type => :list, :order => 16,
	184	:values => [[l(:general_text_yes), "1"], [l(:general_text_no), "0"]]
	185	}
	186	end
	187	Tracker.disabled_core_fields(trackers).each {\|field\|
	188	@available_filters.delete field
	189	}
	190	@available_filters.each do \|field, options\|
	191	options[:name] \|\|= l(options[:label] \|\| "field_#{field}".gsub(/_id$/, ''))
	192	end
	193	@available_filters
	194	end
	195
	196	def available_columns
	197	return @available_columns if @available_columns
	198	@available_columns = self.class.available_columns.dup
	199	@available_columns += (project ?
	200	project.all_issue_custom_fields :
	201	IssueCustomField.all
	202	).collect {\|cf\| QueryCustomFieldColumn.new(cf) }
	203
	204	if User.current.allowed_to?(:view_time_entries, project, :global => true)
	205	index = nil
	206	@available_columns.each_with_index {\|column, i\| index = i if column.name == :estimated_hours}
	207	index = (index ? index + 1 : -1)
	208	# insert the column after estimated_hours or at the end
	209	@available_columns.insert index, QueryColumn.new(:spent_hours,
	210	:sortable => "(SELECT COALESCE(SUM(hours), 0) FROM #{TimeEntry.table_name} WHERE #{TimeEntry.table_name}.issue_id = #{Issue.table_name}.id)",
	211	:default_order => 'desc',
	212	:caption => :label_spent_time
	213	)
	214	end
	215
	216	if User.current.allowed_to?(:set_issues_private, nil, :global => true) \|\|
	217	User.current.allowed_to?(:set_own_issues_private, nil, :global => true)
	218	@available_columns << QueryColumn.new(:is_private, :sortable => "#{Issue.table_name}.is_private")
	219	end
	220
	221	disabled_fields = Tracker.disabled_core_fields(trackers).map {\|field\| field.sub(/_id$/, '')}
	222	@available_columns.reject! {\|column\|
	223	disabled_fields.include?(column.name.to_s)
	224	}
	225
	226	@available_columns
	227	end
	228
	229	# Returns the issue count
	230	def issue_count
	231	Issue.visible.count(:include => [:status, :project], :conditions => statement)
	232	rescue ::ActiveRecord::StatementInvalid => e
	233	raise StatementInvalid.new(e.message)
	234	end
	235
	236	# Returns the issue count by group or nil if query is not grouped
	237	def issue_count_by_group
	238	r = nil
	239	if grouped?
	240	begin
	241	# Rails3 will raise an (unexpected) RecordNotFound if there's only a nil group value
	242	r = Issue.visible.count(:group => group_by_statement, :include => [:status, :project], :conditions => statement)
	243	rescue ActiveRecord::RecordNotFound
	244	r = {nil => issue_count}
	245	end
	246	c = group_by_column
	247	if c.is_a?(QueryCustomFieldColumn)
	248	r = r.keys.inject({}) {\|h, k\| h[c.custom_field.cast_value(k)] = r[k]; h}
	249	end
	250	end
	251	r
	252	rescue ::ActiveRecord::StatementInvalid => e
	253	raise StatementInvalid.new(e.message)
	254	end
	255
	256	# Returns the issues
	257	# Valid options are :order, :offset, :limit, :include, :conditions
	258	def issues(options={})
	259	order_option = [group_by_sort_order, options[:order]].reject {\|s\| s.blank?}.join(',')
	260	order_option = nil if order_option.blank?
	261
	262	issues = Issue.visible.where(options[:conditions]).all(
	263	:include => ([:status, :project] + (options[:include] \|\| [])).uniq,
	264	:conditions => statement,
	265	:order => order_option,
	266	:joins => joins_for_order_statement(order_option),
	267	:limit => options[:limit],
	268	:offset => options[:offset]
	269	)
	270
	271	if has_column?(:spent_hours)
	272	Issue.load_visible_spent_hours(issues)
	273	end
	274	if has_column?(:relations)
	275	Issue.load_visible_relations(issues)
	276	end
	277	issues
	278	rescue ::ActiveRecord::StatementInvalid => e
	279	raise StatementInvalid.new(e.message)
	280	end
	281
	282	# Returns the issues ids
	283	def issue_ids(options={})
	284	order_option = [group_by_sort_order, options[:order]].reject {\|s\| s.blank?}.join(',')
	285	order_option = nil if order_option.blank?
	286
	287	Issue.visible.scoped(:conditions => options[:conditions]).scoped(:include => ([:status, :project] + (options[:include] \|\| [])).uniq,
	288	:conditions => statement,
	289	:order => order_option,
	290	:joins => joins_for_order_statement(order_option),
	291	:limit => options[:limit],
	292	:offset => options[:offset]).find_ids
	293	rescue ::ActiveRecord::StatementInvalid => e
	294	raise StatementInvalid.new(e.message)
	295	end
	296
	297	# Returns the journals
	298	# Valid options are :order, :offset, :limit
	299	def journals(options={})
	300	Journal.visible.all(
	301	:include => [:details, :user, {:issue => [:project, :author, :tracker, :status]}],
	302	:conditions => statement,
	303	:order => options[:order],
	304	:limit => options[:limit],
	305	:offset => options[:offset]
	306	)
	307	rescue ::ActiveRecord::StatementInvalid => e
	308	raise StatementInvalid.new(e.message)
	309	end
	310
	311	# Returns the versions
	312	# Valid options are :conditions
	313	def versions(options={})
	314	Version.visible.where(options[:conditions]).all(
	315	:include => :project,
	316	:conditions => project_statement
	317	)
	318	rescue ::ActiveRecord::StatementInvalid => e
	319	raise StatementInvalid.new(e.message)
	320	end
	321	end

db/migrate/20121209123234_add_queries_type.rb created 644 +9 0

@@ -0,0 +1,9
	1	class AddQueriesType < ActiveRecord::Migration
	2	def up
	3	add_column :queries, :type, :string
	4	end
	5
	6	def down
	7	remove_column :queries, :type
	8	end
	9	end

db/migrate/20121209123358_update_queries_to_sti.rb created 644 +9 0

@@ -0,0 +1,9
	1	class UpdateQueriesToSti < ActiveRecord::Migration
	2	def up
	3	::Query.update_all :type => 'IssueQuery'
	4	end
	5
	6	def down
	7	::Query.update_all :type => nil
	8	end
	9	end

app/controllers/queries_controller.rb +5 -5

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 QueriesController < ApplicationController
               menu_item :issues
               before_filter :find_query, :except => [:new, :create, :index]
               before_filter :find_optional_project, :only => [:new, :create]
               accept_api_auth :index
               include QueriesHelper
               def index
                 case params[:format]
                 when 'xml', 'json'
                   @offset, @limit = api_offset_and_limit
                 else
                   @limit = per_page_option
                 end
-                @query_count = Query.visible.count
+                @query_count = IssueQuery.visible.count
                 @query_pages = Paginator.new self, @query_count, @limit, params['page']
-                @queries = Query.visible.all(:limit => @limit, :offset => @offset, :order => "#{Query.table_name}.name")
+                @queries = IssueQuery.visible.all(:limit => @limit, :offset => @offset, :order => "#{Query.table_name}.name")
                 respond_to do |format|
                   format.html { render :nothing => true }
                   format.api
                 end
               end
               def new
-                @query = Query.new
+                @query = IssueQuery.new
                 @query.user = User.current
                 @query.project = @project
                 @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?
                 build_query_from_params
               end
               def create
-                @query = Query.new(params[:query])
+                @query = IssueQuery.new(params[:query])
                 @query.user = User.current
                 @query.project = params[:query_is_for_all] ? nil : @project
                 @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?
                 build_query_from_params
                 @query.column_names = nil if params[:default_columns]
                 if @query.save
                   flash[:notice] = l(:notice_successful_create)
                   redirect_to :controller => 'issues', :action => 'index', :project_id => @project, :query_id => @query
                 else
                   render :action => 'new', :layout => !request.xhr?
                 end
               end
               def edit
               end
               def update
                 @query.attributes = params[:query]
                 @query.project = nil if params[:query_is_for_all]
                 @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?
                 build_query_from_params
                 @query.column_names = nil if params[:default_columns]
                 if @query.save
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to :controller => 'issues', :action => 'index', :project_id => @project, :query_id => @query
                 else
                   render :action => 'edit'
                 end
               end
               def destroy
                 @query.destroy
                 redirect_to :controller => 'issues', :action => 'index', :project_id => @project, :set_filter => 1
               end
             private
               def find_query
-                @query = Query.find(params[:id])
+                @query = IssueQuery.find(params[:id])
                 @project = @query.project
                 render_403 unless @query.editable_by?(User.current)
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_optional_project
                 @project = Project.find(params[:project_id]) if params[:project_id]
                 render_403 unless User.current.allowed_to?(:save_queries, @project, :global => true)
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/helpers/issues_helper.rb +1 -1

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2012  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 IssuesHelper
               include ApplicationHelper
               def issue_list(issues, &block)
                 ancestors = []
                 issues.each do |issue|
                   while (ancestors.any? && !issue.is_descendant_of?(ancestors.last))
                     ancestors.pop
                   end
                   yield issue, ancestors.size
                   ancestors << issue unless issue.leaf?
                 end
               end
               # Renders a HTML/CSS tooltip
               #
               # To use, a trigger div is needed.  This is a div with the class of "tooltip"
               # that contains this method wrapped in a span with the class of "tip"
               #
               #    <div class="tooltip"><%= link_to_issue(issue) %>
               #      <span class="tip"><%= render_issue_tooltip(issue) %></span>
               #    </div>
               #
               def render_issue_tooltip(issue)
                 @cached_label_status ||= l(:field_status)
                 @cached_label_start_date ||= l(:field_start_date)
                 @cached_label_due_date ||= l(:field_due_date)
                 @cached_label_assigned_to ||= l(:field_assigned_to)
                 @cached_label_priority ||= l(:field_priority)
                 @cached_label_project ||= l(:field_project)
                 link_to_issue(issue) + "<br /><br />".html_safe +
                   "<strong>#{@cached_label_project}</strong>: #{link_to_project(issue.project)}<br />".html_safe +
                   "<strong>#{@cached_label_status}</strong>: #{h(issue.status.name)}<br />".html_safe +
                   "<strong>#{@cached_label_start_date}</strong>: #{format_date(issue.start_date)}<br />".html_safe +
                   "<strong>#{@cached_label_due_date}</strong>: #{format_date(issue.due_date)}<br />".html_safe +
                   "<strong>#{@cached_label_assigned_to}</strong>: #{h(issue.assigned_to)}<br />".html_safe +
                   "<strong>#{@cached_label_priority}</strong>: #{h(issue.priority.name)}".html_safe
               end
               def issue_heading(issue)
                 h("#{issue.tracker} ##{issue.id}")
               end
               def render_issue_subject_with_tree(issue)
                 s = ''
                 ancestors = issue.root? ? [] : issue.ancestors.visible.all
                 ancestors.each do |ancestor|
                   s << '<div>' + content_tag('p', link_to_issue(ancestor, :project => (issue.project_id != ancestor.project_id)))
                 end
                 s << '<div>'
                 subject = h(issue.subject)
                 if issue.is_private?
                   subject = content_tag('span', l(:field_is_private), :class => 'private') + ' ' + subject
                 end
                 s << content_tag('h3', subject)
                 s << '</div>' * (ancestors.size + 1)
                 s.html_safe
               end
               def render_descendants_tree(issue)
                 s = '<form><table class="list issues">'
                 issue_list(issue.descendants.visible.sort_by(&:lft)) do |child, level|
                   css = "issue issue-#{child.id} hascontextmenu"
                   css << " idnt idnt-#{level}" if level > 0
                   s << content_tag('tr',
                          content_tag('td', check_box_tag("ids[]", child.id, false, :id => nil), :class => 'checkbox') +
                          content_tag('td', link_to_issue(child, :truncate => 60, :project => (issue.project_id != child.project_id)), :class => 'subject') +
                          content_tag('td', h(child.status)) +
                          content_tag('td', link_to_user(child.assigned_to)) +
                          content_tag('td', progress_bar(child.done_ratio, :width => '80px')),
                          :class => css)
                 end
                 s << '</table></form>'
                 s.html_safe
               end
               # Returns a link for adding a new subtask to the given issue
               def link_to_new_subtask(issue)
                 attrs = {
                   :tracker_id => issue.tracker,
                   :parent_issue_id => issue
                 }
                 link_to(l(:button_add), new_project_issue_path(issue.project, :issue => attrs))
               end
               class IssueFieldsRows
                 include ActionView::Helpers::TagHelper
                 def initialize
                   @left = []
                   @right = []
                 end
                 def left(*args)
                   args.any? ? @left << cells(*args) : @left
                 end
                 def right(*args)
                   args.any? ? @right << cells(*args) : @right
                 end
                 def size
                   @left.size > @right.size ? @left.size : @right.size
                 end
                 def to_html
                   html = ''.html_safe
                   blank = content_tag('th', '') + content_tag('td', '')
                   size.times do |i|
                     left = @left[i] || blank
                     right = @right[i] || blank
                     html << content_tag('tr', left + right)
                   end
                   html
                 end
                 def cells(label, text, options={})
                   content_tag('th', "#{label}:", options) + content_tag('td', text, options)
                 end
               end
               def issue_fields_rows
                 r = IssueFieldsRows.new
                 yield r
                 r.to_html
               end
               def render_custom_fields_rows(issue)
                 return if issue.custom_field_values.empty?
                 ordered_values = []
                 half = (issue.custom_field_values.size / 2.0).ceil
                 half.times do |i|
                   ordered_values << issue.custom_field_values[i]
                   ordered_values << issue.custom_field_values[i + half]
                 end
                 s = "<tr>\n"
                 n = 0
                 ordered_values.compact.each do |value|
                   s << "</tr>\n<tr>\n" if n > 0 && (n % 2) == 0
                   s << "\t<th>#{ h(value.custom_field.name) }:</th><td>#{ simple_format_without_paragraph(h(show_value(value))) }</td>\n"
                   n += 1
                 end
                 s << "</tr>\n"
                 s.html_safe
               end
               def issues_destroy_confirmation_message(issues)
                 issues = [issues] unless issues.is_a?(Array)
                 message = l(:text_issues_destroy_confirmation)
                 descendant_count = issues.inject(0) {|memo, i| memo += (i.right - i.left - 1)/2}
                 if descendant_count > 0
                   issues.each do |issue|
                     next if issue.root?
                     issues.each do |other_issue|
                       descendant_count -= 1 if issue.is_descendant_of?(other_issue)
                     end
                   end
                   if descendant_count > 0
                     message << "\n" + l(:text_issues_destroy_descendants_confirmation, :count => descendant_count)
                   end
                 end
                 message
               end
               def sidebar_queries
                 unless @sidebar_queries
-                  @sidebar_queries = Query.visible.all(
+                  @sidebar_queries = IssueQuery.visible.all(
                     :order => "#{Query.table_name}.name ASC",
                     # Project specific queries and global queries
                     :conditions => (@project.nil? ? ["project_id IS NULL"] : ["project_id IS NULL OR project_id = ?", @project.id])
                   )
                 end
                 @sidebar_queries
               end
               def query_links(title, queries)
                 # links to #index on issues/show
                 url_params = controller_name == 'issues' ? {:controller => 'issues', :action => 'index', :project_id => @project} : params
                 content_tag('h3', h(title)) +
                   queries.collect {|query|
                       css = 'query'
                       css << ' selected' if query == @query
                       link_to(h(query.name), url_params.merge(:query_id => query), :class => css)
                     }.join('<br />').html_safe
               end
               def render_sidebar_queries
                 out = ''.html_safe
                 queries = sidebar_queries.select {|q| !q.is_public?}
                 out << query_links(l(:label_my_queries), queries) if queries.any?
                 queries = sidebar_queries.select {|q| q.is_public?}
                 out << query_links(l(:label_query_plural), queries) if queries.any?
                 out
               end
               # Returns the textual representation of a journal details
               # as an array of strings
               def details_to_strings(details, no_html=false, options={})
                 options[:only_path] = (options[:only_path] == false ? false : true)
                 strings = []
                 values_by_field = {}
                 details.each do |detail|
                   if detail.property == 'cf'
                     field_id = detail.prop_key
                     field = CustomField.find_by_id(field_id)
                     if field && field.multiple?
                       values_by_field[field_id] ||= {:added => [], :deleted => []}
                       if detail.old_value
                         values_by_field[field_id][:deleted] << detail.old_value
                       end
                       if detail.value
                         values_by_field[field_id][:added] << detail.value
                       end
                       next
                     end
                   end
                   strings << show_detail(detail, no_html, options)
                 end
                 values_by_field.each do |field_id, changes|
                   detail = JournalDetail.new(:property => 'cf', :prop_key => field_id)
                   if changes[:added].any?
                     detail.value = changes[:added]
                     strings << show_detail(detail, no_html, options)
                   elsif changes[:deleted].any?
                     detail.old_value = changes[:deleted]
                     strings << show_detail(detail, no_html, options)
                   end
                 end
                 strings
               end
               # Returns the textual representation of a single journal detail
               def show_detail(detail, no_html=false, options={})
                 multiple = false
                 case detail.property
                 when 'attr'
                   field = detail.prop_key.to_s.gsub(/\_id$/, "")
                   label = l(("field_" + field).to_sym)
                   case detail.prop_key
                   when 'due_date', 'start_date'
                     value = format_date(detail.value.to_date) if detail.value
                     old_value = format_date(detail.old_value.to_date) if detail.old_value
                   when 'project_id', 'status_id', 'tracker_id', 'assigned_to_id',
                         'priority_id', 'category_id', 'fixed_version_id'
                     value = find_name_by_reflection(field, detail.value)
                     old_value = find_name_by_reflection(field, detail.old_value)
                   when 'estimated_hours'
                     value = "%0.02f" % detail.value.to_f unless detail.value.blank?
                     old_value = "%0.02f" % detail.old_value.to_f unless detail.old_value.blank?
                   when 'parent_id'
                     label = l(:field_parent_issue)
                     value = "##{detail.value}" unless detail.value.blank?
                     old_value = "##{detail.old_value}" unless detail.old_value.blank?
                   when 'is_private'
                     value = l(detail.value == "0" ? :general_text_No : :general_text_Yes) unless detail.value.blank?
                     old_value = l(detail.old_value == "0" ? :general_text_No : :general_text_Yes) unless detail.old_value.blank?
                   end
                 when 'cf'
                   custom_field = CustomField.find_by_id(detail.prop_key)
                   if custom_field
                     multiple = custom_field.multiple?
                     label = custom_field.name
                     value = format_value(detail.value, custom_field.field_format) if detail.value
                     old_value = format_value(detail.old_value, custom_field.field_format) if detail.old_value
                   end
                 when 'attachment'
                   label = l(:label_attachment)
                 end
                 call_hook(:helper_issues_show_detail_after_setting,
                           {:detail => detail, :label => label, :value => value, :old_value => old_value })
                 label ||= detail.prop_key
                 value ||= detail.value
                 old_value ||= detail.old_value
                 unless no_html
                   label = content_tag('strong', label)
                   old_value = content_tag("i", h(old_value)) if detail.old_value
                   old_value = content_tag("del", old_value) if detail.old_value and detail.value.blank?
                   if detail.property == 'attachment' && !value.blank? && atta = Attachment.find_by_id(detail.prop_key)
                     # Link to the attachment if it has not been removed
                     value = link_to_attachment(atta, :download => true, :only_path => options[:only_path])
                     if options[:only_path] != false && atta.is_text?
                       value += link_to(
                                    image_tag('magnifier.png'),
                                    :controller => 'attachments', :action => 'show',
                                    :id => atta, :filename => atta.filename
                                  )
                     end
                   else
                     value = content_tag("i", h(value)) if value
                   end
                 end
                 if detail.property == 'attr' && detail.prop_key == 'description'
                   s = l(:text_journal_changed_no_detail, :label => label)
                   unless no_html
                     diff_link = link_to 'diff',
                       {:controller => 'journals', :action => 'diff', :id => detail.journal_id,
                        :detail_id => detail.id, :only_path => options[:only_path]},
                       :title => l(:label_view_diff)
                     s << " (#{ diff_link })"
                   end
                   s.html_safe
                 elsif detail.value.present?
                   case detail.property
                   when 'attr', 'cf'
                     if detail.old_value.present?
                       l(:text_journal_changed, :label => label, :old => old_value, :new => value).html_safe
                     elsif multiple
                       l(:text_journal_added, :label => label, :value => value).html_safe
                     else
                       l(:text_journal_set_to, :label => label, :value => value).html_safe
                     end
                   when 'attachment'
                     l(:text_journal_added, :label => label, :value => value).html_safe
                   end
                 else
                   l(:text_journal_deleted, :label => label, :old => old_value).html_safe
                 end
               end
               # Find the name of an associated record stored in the field attribute
               def find_name_by_reflection(field, id)
                 association = Issue.reflect_on_association(field.to_sym)
                 if association
                   record = association.class_name.constantize.find_by_id(id)
                   return record.name if record
                 end
               end
               # Renders issue children recursively
               def render_api_issue_children(issue, api)
                 return if issue.leaf?
                 api.array :children do
                   issue.children.each do |child|
                     api.issue(:id => child.id) do
                       api.tracker(:id => child.tracker_id, :name => child.tracker.name) unless child.tracker.nil?
                       api.subject child.subject
                       render_api_issue_children(child, api)
                     end
                   end
                 end
               end
               def issues_to_csv(issues, project, query, options={})
                 decimal_separator = l(:general_csv_decimal_separator)
                 encoding = l(:general_csv_encoding)
                 columns = (options[:columns] == 'all' ? query.available_inline_columns : query.inline_columns)
                 if options[:description]
                   if description = query.available_columns.detect {|q| q.name == :description}
                     columns << description
                   end
                 end
                 export = FCSV.generate(:col_sep => l(:general_csv_separator)) do |csv|
                   # csv header fields
                   csv << [ "#" ] + columns.collect {|c| Redmine::CodesetUtil.from_utf8(c.caption.to_s, encoding) }
                   # csv lines
                   issues.each do |issue|
                     col_values = columns.collect do |column|
                       s = if column.is_a?(QueryCustomFieldColumn)
                         cv = issue.custom_field_values.detect {|v| v.custom_field_id == column.custom_field.id}
                         show_value(cv)
                       else
                         value = column.value(issue)
                         if value.is_a?(Date)
                           format_date(value)
                         elsif value.is_a?(Time)
                           format_time(value)
                         elsif value.is_a?(Float)
                           ("%.2f" % value).gsub('.', decimal_separator)
                         else
                           value
                         end
                       end
                       s.to_s
                     end
                     csv << [ issue.id.to_s ] + col_values.collect {|c| Redmine::CodesetUtil.from_utf8(c.to_s, encoding) }
                   end
                 end
                 export
               end
             end

app/helpers/queries_helper.rb +6 -6

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2012  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 QueriesHelper
               def filters_options_for_select(query)
                 options_for_select(filters_options(query))
               end
               def filters_options(query)
                 options = [[]]
                 sorted_options = query.available_filters.sort do |a, b|
                   ord = 0
                   if !(a[1][:order] == 20 && b[1][:order] == 20)
                     ord = a[1][:order] <=> b[1][:order]
                   else
                     cn = (CustomField::CUSTOM_FIELDS_NAMES.index(a[1][:field].class.name) <=>
                             CustomField::CUSTOM_FIELDS_NAMES.index(b[1][:field].class.name))
                     if cn != 0
                       ord = cn
                     else
                       f = (a[1][:field] <=> b[1][:field])
                       if f != 0
                         ord = f
                       else
                         # assigned_to or author
                         ord = (a[0] <=> b[0])
                       end
                     end
                   end
                   ord
                 end
                 options += sorted_options.map do |field, field_options|
                   [field_options[:name], field]
                 end
               end
               def available_block_columns_tags(query)
                 tags = ''.html_safe
                 query.available_block_columns.each do |column|
                   tags << content_tag('label', check_box_tag('c[]', column.name.to_s, query.has_column?(column)) + " #{column.caption}", :class => 'inline')
                 end
                 tags
               end
               def column_header(column)
                 column.sortable ? sort_header_tag(column.name.to_s, :caption => column.caption,
                                                                     :default_order => column.default_order) :
                                   content_tag('th', h(column.caption))
               end
               def column_content(column, issue)
                 value = column.value(issue)
                 if value.is_a?(Array)
                   value.collect {|v| column_value(column, issue, v)}.compact.join(', ').html_safe
                 else
                   column_value(column, issue, value)
                 end
               end
               def column_value(column, issue, value)
                 case value.class.name
                 when 'String'
                   if column.name == :subject
                     link_to(h(value), :controller => 'issues', :action => 'show', :id => issue)
                   elsif column.name == :description
                     issue.description? ? content_tag('div', textilizable(issue, :description), :class => "wiki") : ''
                   else
                     h(value)
                   end
                 when 'Time'
                   format_time(value)
                 when 'Date'
                   format_date(value)
                 when 'Fixnum', 'Float'
                   if column.name == :done_ratio
                     progress_bar(value, :width => '80px')
                   elsif  column.name == :spent_hours
                     sprintf "%.2f", value
                   else
                     h(value.to_s)
                   end
                 when 'User'
                   link_to_user value
                 when 'Project'
                   link_to_project value
                 when 'Version'
                   link_to(h(value), :controller => 'versions', :action => 'show', :id => value)
                 when 'TrueClass'
                   l(:general_text_Yes)
                 when 'FalseClass'
                   l(:general_text_No)
                 when 'Issue'
                   link_to_issue(value, :subject => false)
                 when 'IssueRelation'
                   other = value.other_issue(issue)
                   content_tag('span',
                     (l(value.label_for(issue)) + " " + link_to_issue(other, :subject => false, :tracker => false)).html_safe,
                     :class => value.css_classes_for(issue))
                 else
                   h(value)
                 end
               end
               # Retrieve query from session or build a new query
               def retrieve_query
                 if !params[:query_id].blank?
                   cond = "project_id IS NULL"
                   cond << " OR project_id = #{@project.id}" if @project
-                  @query = Query.find(params[:query_id], :conditions => cond)
+                  @query = IssueQuery.find(params[:query_id], :conditions => cond)
                   raise ::Unauthorized unless @query.visible?
                   @query.project = @project
                   session[:query] = {:id => @query.id, :project_id => @query.project_id}
                   sort_clear
                 elsif api_request? || params[:set_filter] || session[:query].nil? || session[:query][:project_id] != (@project ? @project.id : nil)
                   # Give it a name, required to be valid
-                  @query = Query.new(:name => "_")
+                  @query = IssueQuery.new(:name => "_")
                   @query.project = @project
                   build_query_from_params
                   session[:query] = {:project_id => @query.project_id, :filters => @query.filters, :group_by => @query.group_by, :column_names => @query.column_names}
                 else
                   # retrieve from session
-                  @query = Query.find_by_id(session[:query][:id]) if session[:query][:id]
+                  @query = IssueQuery.find_by_id(session[:query][:id]) if session[:query][:id]
-                  @query ||= Query.new(:name => "_", :filters => session[:query][:filters], :group_by => session[:query][:group_by], :column_names => session[:query][:column_names])
+                  @query ||= IssueQuery.new(:name => "_", :filters => session[:query][:filters], :group_by => session[:query][:group_by], :column_names => session[:query][:column_names])
                   @query.project = @project
                 end
               end
               def retrieve_query_from_session
                 if session[:query]
                   if session[:query][:id]
-                    @query = Query.find_by_id(session[:query][:id])
+                    @query = IssueQuery.find_by_id(session[:query][:id])
                     return unless @query
                   else
-                    @query = Query.new(:name => "_", :filters => session[:query][:filters], :group_by => session[:query][:group_by], :column_names => session[:query][:column_names])
+                    @query = IssueQuery.new(:name => "_", :filters => session[:query][:filters], :group_by => session[:query][:group_by], :column_names => session[:query][:column_names])
                   end
                   if session[:query].has_key?(:project_id)
                     @query.project_id = session[:query][:project_id]
                   else
                     @query.project = @project
                   end
                   @query
                 end
               end
               def build_query_from_params
                 if params[:fields] || params[:f]
                   @query.filters = {}
                   @query.add_filters(params[:fields] || params[:f], params[:operators] || params[:op], params[:values] || params[:v])
                 else
                   @query.available_filters.keys.each do |field|
                     @query.add_short_filter(field, params[field]) if params[field]
                   end
                 end
                 @query.group_by = params[:group_by] || (params[:query] && params[:query][:group_by])
                 @query.column_names = params[:c] || (params[:query] && params[:query][:column_names])
               end
             end

app/models/project.rb +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2012  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
               include Redmine::SafeAttributes
               # Project statuses
               STATUS_ACTIVE     = 1
               STATUS_CLOSED     = 5
               STATUS_ARCHIVED   = 9
               # Maximum length for project identifiers
               IDENTIFIER_MAX_LENGTH = 100
               # Specific overidden Activities
               has_many :time_entry_activities
               has_many :members, :include => [:principal, :roles], :conditions => "#{Principal.table_name}.type='User' AND #{Principal.table_name}.status=#{Principal::STATUS_ACTIVE}"
               has_many :memberships, :class_name => 'Member'
               has_many :member_principals, :class_name => 'Member',
                                            :include => :principal,
                                            :conditions => "#{Principal.table_name}.type='Group' OR (#{Principal.table_name}.type='User' AND #{Principal.table_name}.status=#{Principal::STATUS_ACTIVE})"
               has_many :users, :through => :members
               has_many :principals, :through => :member_principals, :source => :principal
               has_many :enabled_modules, :dependent => :delete_all
               has_and_belongs_to_many :trackers, :order => "#{Tracker.table_name}.position"
               has_many :issues, :dependent => :destroy, :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 :queries, :class_name => 'IssueQuery', :dependent => :delete_all
               has_many :documents, :dependent => :destroy
               has_many :news, :dependent => :destroy, :include => :author
               has_many :issue_categories, :dependent => :delete_all, :order => "#{IssueCategory.table_name}.name"
               has_many :boards, :dependent => :destroy, :order => "position ASC"
               has_one :repository, :conditions => ["is_default = ?", true]
               has_many :repositories, :dependent => :destroy
               has_many :changesets, :through => :repository
               has_one :wiki, :dependent => :destroy
               # Custom field for the project issues
               has_and_belongs_to_many :issue_custom_fields,
                                       :class_name => 'IssueCustomField',
                                       :order => "#{CustomField.table_name}.position",
                                       :join_table => "#{table_name_prefix}custom_fields_projects#{table_name_suffix}",
                                       :association_foreign_key => 'custom_field_id'
               acts_as_nested_set :order => 'name', :dependent => :destroy
               acts_as_attachable :view_permission => :view_files,
                                  :delete_permission => :manage_files
               acts_as_customizable
               acts_as_searchable :columns => ['name', 'identifier', 'description'], :project_key => 'id', :permission => nil
               acts_as_event :title => Proc.new {|o| "#{l(:label_project)}: #{o.name}"},
                             :url => Proc.new {|o| {:controller => 'projects', :action => 'show', :id => o}},
                             :author => nil
               attr_protected :status
               validates_presence_of :name, :identifier
               validates_uniqueness_of :identifier
               validates_associated :repository, :wiki
               validates_length_of :name, :maximum => 255
               validates_length_of :homepage, :maximum => 255
               validates_length_of :identifier, :in => 1..IDENTIFIER_MAX_LENGTH
               # donwcase letters, digits, dashes but not digits only
               validates_format_of :identifier, :with => /\A(?!\d+$)[a-z0-9\-_]*\z/, :if => Proc.new { |p| p.identifier_changed? }
               # reserved words
               validates_exclusion_of :identifier, :in => %w( new )
               after_save :update_position_under_parent, :if => Proc.new {|project| project.name_changed?}
               before_destroy :delete_all_members
               scope :has_module, lambda {|mod|
                 where("#{Project.table_name}.id IN (SELECT em.project_id FROM #{EnabledModule.table_name} em WHERE em.name=?)", mod.to_s)
               }
               scope :active, lambda { where(:status => STATUS_ACTIVE) }
               scope :status, lambda {|arg| where(arg.blank? ? nil : {:status => arg.to_i}) }
               scope :all_public, lambda { where(:is_public => true) }
               scope :visible, lambda {|*args| where(Project.visible_condition(args.shift || User.current, *args)) }
               scope :allowed_to, lambda {|*args|
                 user = User.current
                 permission = nil
                 if args.first.is_a?(Symbol)
                   permission = args.shift
                 else
                   user = args.shift
                   permission = args.shift
                 end
                 where(Project.allowed_to_condition(user, permission, *args))
               }
               scope :like, lambda {|arg|
                 if arg.blank?
                   where(nil)
                 else
                   pattern = "%#{arg.to_s.strip.downcase}%"
                   where("LOWER(identifier) LIKE :p OR LOWER(name) LIKE :p", :p => pattern)
                 end
               }
               def initialize(attributes=nil, *args)
                 super
                 initialized = (attributes || {}).stringify_keys
                 if !initialized.key?('identifier') && Setting.sequential_project_identifiers?
                   self.identifier = Project.next_identifier
                 end
                 if !initialized.key?('is_public')
                   self.is_public = Setting.default_projects_public?
                 end
                 if !initialized.key?('enabled_module_names')
                   self.enabled_module_names = Setting.default_projects_modules
                 end
                 if !initialized.key?('trackers') && !initialized.key?('tracker_ids')
                   self.trackers = Tracker.sorted.all
                 end
               end
               def identifier=(identifier)
                 super unless identifier_frozen?
               end
               def identifier_frozen?
                 errors[:identifier].blank? && !(new_record? || identifier.blank?)
               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)
                 visible(user).limit(count).order("created_on DESC").all
               end
               # Returns true if the project is visible to +user+ or to the current user.
               def visible?(user=User.current)
                 user.allowed_to?(:view_project, self)
               end
               # Returns a SQL conditions string used to find all projects visible by the specified user.
               #
               # Examples:
               #   Project.visible_condition(admin)        => "projects.status = 1"
               #   Project.visible_condition(normal_user)  => "((projects.status = 1) AND (projects.is_public = 1 OR projects.id IN (1,3,4)))"
               #   Project.visible_condition(anonymous)    => "((projects.status = 1) AND (projects.is_public = 1))"
               def self.visible_condition(user, options={})
                 allowed_to_condition(user, :view_project, options)
               end
               # Returns a SQL conditions string used to find all projects for which +user+ has the given +permission+
               #
               # Valid options:
               # * :project => limit the condition to project
               # * :with_subprojects => limit the condition to project and its subprojects
               # * :member => limit the condition to the user projects
               def self.allowed_to_condition(user, permission, options={})
                 perm = Redmine::AccessControl.permission(permission)
                 base_statement = (perm && perm.read? ? "#{Project.table_name}.status <> #{Project::STATUS_ARCHIVED}" : "#{Project.table_name}.status = #{Project::STATUS_ACTIVE}")
                 if perm && perm.project_module
                   # If the permission belongs to a project module, make sure the module is enabled
                   base_statement << " AND #{Project.table_name}.id IN (SELECT em.project_id FROM #{EnabledModule.table_name} em WHERE em.name='#{perm.project_module}')"
                 end
                 if options[:project]
                   project_statement = "#{Project.table_name}.id = #{options[:project].id}"
                   project_statement << " OR (#{Project.table_name}.lft > #{options[:project].lft} AND #{Project.table_name}.rgt < #{options[:project].rgt})" if options[:with_subprojects]
                   base_statement = "(#{project_statement}) AND (#{base_statement})"
                 end
                 if user.admin?
                   base_statement
                 else
                   statement_by_role = {}
                   unless options[:member]
                     role = user.logged? ? Role.non_member : Role.anonymous
                     if role.allowed_to?(permission)
                       statement_by_role[role] = "#{Project.table_name}.is_public = #{connection.quoted_true}"
                     end
                   end
                   if user.logged?
                     user.projects_by_role.each do |role, projects|
                       if role.allowed_to?(permission) && projects.any?
                         statement_by_role[role] = "#{Project.table_name}.id IN (#{projects.collect(&:id).join(',')})"
                       end
                     end
                   end
                   if statement_by_role.empty?
                     "1=0"
                   else
                     if block_given?
                       statement_by_role.each do |role, statement|
                         if s = yield(role, user)
                           statement_by_role[role] = "(#{statement} AND (#{s}))"
                         end
                       end
                     end
                     "((#{base_statement}) AND (#{statement_by_role.values.join(' OR ')}))"
                   end
                 end
               end
               # Returns the Systemwide and project specific activities
               def activities(include_inactive=false)
                 if include_inactive
                   return all_activities
                 else
                   return active_activities
                 end
               end
               # Will create a new Project specific Activity or update an existing one
               #
               # This will raise a ActiveRecord::Rollback if the TimeEntryActivity
               # does not successfully save.
               def update_or_create_time_entry_activity(id, activity_hash)
                 if activity_hash.respond_to?(:has_key?) && activity_hash.has_key?('parent_id')
                   self.create_time_entry_activity_if_needed(activity_hash)
                 else
                   activity = project.time_entry_activities.find_by_id(id.to_i)
                   activity.update_attributes(activity_hash) if activity
                 end
               end
               # Create a new TimeEntryActivity if it overrides a system TimeEntryActivity
               #
               # This will raise a ActiveRecord::Rollback if the TimeEntryActivity
               # does not successfully save.
               def create_time_entry_activity_if_needed(activity)
                 if activity['parent_id']
                   parent_activity = TimeEntryActivity.find(activity['parent_id'])
                   activity['name'] = parent_activity.name
                   activity['position'] = parent_activity.position
                   if Enumeration.overridding_change?(activity, parent_activity)
                     project_activity = self.time_entry_activities.create(activity)
                     if project_activity.new_record?
                       raise ActiveRecord::Rollback, "Overridding TimeEntryActivity was not successfully saved"
                     else
                       self.time_entries.update_all("activity_id = #{project_activity.id}", ["activity_id = ?", parent_activity.id])
                     end
                   end
                 end
               end
               # Returns a :conditions SQL string that can be used to find the issues associated with this project.
               #
               # Examples:
               #   project.project_condition(true)  => "(projects.id = 1 OR (projects.lft > 1 AND projects.rgt < 10))"
               #   project.project_condition(false) => "projects.id = 1"
               def project_condition(with_subprojects)
                 cond = "#{Project.table_name}.id = #{id}"
                 cond = "(#{cond} OR (#{Project.table_name}.lft > #{lft} AND #{Project.table_name}.rgt < #{rgt}))" if with_subprojects
                 cond
               end
               def self.find(*args)
                 if args.first && args.first.is_a?(String) && !args.first.match(/^\d*$/)
                   project = find_by_identifier(*args)
                   raise ActiveRecord::RecordNotFound, "Couldn't find Project with identifier=#{args.first}" if project.nil?
                   project
                 else
                   super
                 end
               end
               def self.find_by_param(*args)
                 self.find(*args)
               end
               def reload(*args)
                 @shared_versions = nil
                 @rolled_up_versions = nil
                 @rolled_up_trackers = nil
                 @all_issue_custom_fields = nil
                 @all_time_entry_custom_fields = nil
                 @to_param = nil
                 @allowed_parents = nil
                 @allowed_permissions = nil
                 @actions_allowed = nil
                 super
               end
               def to_param
                 # id is used for projects with a numeric identifier (compatibility)
                 @to_param ||= (identifier.to_s =~ %r{^\d*$} ? id.to_s : identifier)
               end
               def active?
                 self.status == STATUS_ACTIVE
               end
               def archived?
                 self.status == STATUS_ARCHIVED
               end
               # Archives the project and its descendants
               def archive
                 # Check that there is no issue of a non descendant project that is assigned
                 # to one of the project or descendant versions
                 v_ids = self_and_descendants.collect {|p| p.version_ids}.flatten
                 if v_ids.any? &&
                   Issue.
                     includes(:project).
                     where("#{Project.table_name}.lft < ? OR #{Project.table_name}.rgt > ?", lft, rgt).
                     where("#{Issue.table_name}.fixed_version_id IN (?)", v_ids).
                     exists?
                   return false
                 end
                 Project.transaction do
                   archive!
                 end
                 true
               end
               # Unarchives the project
               # All its ancestors must be active
               def unarchive
                 return false if ancestors.detect {|a| !a.active?}
                 update_attribute :status, STATUS_ACTIVE
               end
               def close
                 self_and_descendants.status(STATUS_ACTIVE).update_all :status => STATUS_CLOSED
               end
               def reopen
                 self_and_descendants.status(STATUS_CLOSED).update_all :status => STATUS_ACTIVE
               end
               # Returns an array of projects the project can be moved to
               # by the current user
               def allowed_parents
                 return @allowed_parents if @allowed_parents
                 @allowed_parents = Project.where(Project.allowed_to_condition(User.current, :add_subprojects)).all
                 @allowed_parents = @allowed_parents - self_and_descendants
                 if User.current.allowed_to?(:add_project, nil, :global => true) || (!new_record? && parent.nil?)
                   @allowed_parents << nil
                 end
                 unless parent.nil? || @allowed_parents.empty? || @allowed_parents.include?(parent)
                   @allowed_parents << parent
                 end
                 @allowed_parents
               end
               # Sets the parent of the project with authorization check
               def set_allowed_parent!(p)
                 unless p.nil? || p.is_a?(Project)
                   if p.to_s.blank?
                     p = nil
                   else
                     p = Project.find_by_id(p)
                     return false unless p
                   end
                 end
                 if p.nil?
                   if !new_record? && allowed_parents.empty?
                     return false
                   end
                 elsif !allowed_parents.include?(p)
                   return false
                 end
                 set_parent!(p)
               end
               # Sets the parent of the project
               # Argument can be either a Project, a String, a Fixnum or nil
               def set_parent!(p)
                 unless p.nil? || p.is_a?(Project)
                   if p.to_s.blank?
                     p = nil
                   else
                     p = Project.find_by_id(p)
                     return false unless p
                   end
                 end
                 if p == parent && !p.nil?
                   # Nothing to do
                   true
                 elsif p.nil? || (p.active? && move_possible?(p))
                   set_or_update_position_under(p)
                   Issue.update_versions_from_hierarchy_change(self)
                   true
                 else
                   # Can not move to the given target
                   false
                 end
               end
               # Recalculates all lft and rgt values based on project names
               # Unlike Project.rebuild!, these values are recalculated even if the tree "looks" valid
               # Used in BuildProjectsTree migration
               def self.rebuild_tree!
                 transaction do
                   update_all "lft = NULL, rgt = NULL"
                   rebuild!(false)
                 end
               end
               # Returns an array of the trackers used by the project and its active sub projects
               def rolled_up_trackers
                 @rolled_up_trackers ||=
                   Tracker.
                     joins(:projects).
                     select("DISTINCT #{Tracker.table_name}.*").
                     where("#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ? AND #{Project.table_name}.status <> #{STATUS_ARCHIVED}", lft, rgt).
                     sorted.
                     all
               end
               # Closes open and locked project versions that are completed
               def close_completed_versions
                 Version.transaction do
                   versions.where(:status => %w(open locked)).all.each do |version|
                     if version.completed?
                       version.update_attribute(:status, 'closed')
                     end
                   end
                 end
               end
               # Returns a scope of the Versions on subprojects
               def rolled_up_versions
                 @rolled_up_versions ||=
                   Version.scoped(:include => :project,
                                  :conditions => ["#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ? AND #{Project.table_name}.status <> #{STATUS_ARCHIVED}", lft, rgt])
               end
               # Returns a scope of the Versions used by the project
               def shared_versions
                 if new_record?
                   Version.scoped(:include => :project,
                                  :conditions => "#{Project.table_name}.status <> #{Project::STATUS_ARCHIVED} AND #{Version.table_name}.sharing = 'system'")
                 else
                   @shared_versions ||= begin
                     r = root? ? self : root
                     Version.scoped(:include => :project,
                                    :conditions => "#{Project.table_name}.id = #{id}" +
                                                   " OR (#{Project.table_name}.status <> #{Project::STATUS_ARCHIVED} AND (" +
                                                       " #{Version.table_name}.sharing = 'system'" +
                                                       " OR (#{Project.table_name}.lft >= #{r.lft} AND #{Project.table_name}.rgt <= #{r.rgt} AND #{Version.table_name}.sharing = 'tree')" +
                                                       " OR (#{Project.table_name}.lft < #{lft} AND #{Project.table_name}.rgt > #{rgt} AND #{Version.table_name}.sharing IN ('hierarchy', 'descendants'))" +
                                                       " OR (#{Project.table_name}.lft > #{lft} AND #{Project.table_name}.rgt < #{rgt} AND #{Version.table_name}.sharing = 'hierarchy')" +
                                                       "))")
                   end
                 end
               end
               # Returns a hash of project users grouped by role
               def users_by_role
                 members.includes(:user, :roles).all.inject({}) do |h, m|
                   m.roles.each do |r|
                     h[r] ||= []
                     h[r] << m.user
                   end
                   h
                 end
               end
               # Deletes all project's members
               def delete_all_members
                 me, mr = Member.table_name, MemberRole.table_name
                 connection.delete("DELETE FROM #{mr} WHERE #{mr}.member_id IN (SELECT #{me}.id FROM #{me} WHERE #{me}.project_id = #{id})")
                 Member.delete_all(['project_id = ?', id])
               end
               # Users/groups issues can be assigned to
               def assignable_users
                 assignable = Setting.issue_group_assignment? ? member_principals : members
                 assignable.select {|m| m.roles.detect {|role| role.assignable?}}.collect {|m| m.principal}.sort
               end
               # Returns the mail adresses of users that should be always notified on project events
               def recipients
                 notified_users.collect {|user| user.mail}
               end
               # Returns the users that should be notified on project events
               def notified_users
                 # TODO: User part should be extracted to User#notify_about?
                 members.select {|m| m.principal.present? && (m.mail_notification? || m.principal.mail_notification == 'all')}.collect {|m| m.principal}
               end
               # Returns an array of all custom fields enabled for project issues
               # (explictly associated custom fields and custom fields enabled for all projects)
               def all_issue_custom_fields
                 @all_issue_custom_fields ||= (IssueCustomField.for_all + issue_custom_fields).uniq.sort
               end
               # Returns an array of all custom fields enabled for project time entries
               # (explictly associated custom fields and custom fields enabled for all projects)
               def all_time_entry_custom_fields
                 @all_time_entry_custom_fields ||= (TimeEntryCustomField.for_all + time_entry_custom_fields).uniq.sort
               end
               def project
                 self
               end
               def <=>(project)
                 name.downcase <=> project.name.downcase
               end
               def to_s
                 name
               end
               # Returns a short description of the projects (first lines)
               def short_description(length = 255)
                 description.gsub(/^(.{#{length}}[^\n\r]*).*$/m, '\1...').strip if description
               end
               def css_classes
                 s = 'project'
                 s << ' root' if root?
                 s << ' child' if child?
                 s << (leaf? ? ' leaf' : ' parent')
                 unless active?
                   if archived?
                     s << ' archived'
                   else
                     s << ' closed'
                   end
                 end
                 s
               end
               # The earliest start date of a project, based on it's issues and versions
               def start_date
                 [
                  issues.minimum('start_date'),
                  shared_versions.collect(&:effective_date),
                  shared_versions.collect(&:start_date)
                 ].flatten.compact.min
               end
               # The latest due date of an issue or version
               def due_date
                 [
                  issues.maximum('due_date'),
                  shared_versions.collect(&:effective_date),
                  shared_versions.collect {|v| v.fixed_issues.maximum('due_date')}
                 ].flatten.compact.max
               end
               def overdue?
                 active? && !due_date.nil? && (due_date < Date.today)
               end
               # Returns the percent completed for this project, based on the
               # progress on it's versions.
               def completed_percent(options={:include_subprojects => false})
                 if options.delete(:include_subprojects)
                   total = self_and_descendants.collect(&:completed_percent).sum
                   total / self_and_descendants.count
                 else
                   if versions.count > 0
                     total = versions.collect(&:completed_pourcent).sum
                     total / versions.count
                   else
                   end
                 end
               end
               # Return true if this project allows to do the specified action.
               # action can be:
               # * a parameter-like Hash (eg. :controller => 'projects', :action => 'edit')
               # * a permission Symbol (eg. :edit_project)
               def allows_to?(action)
                 if archived?
                   # No action allowed on archived projects
                   return false
                 end
                 unless active? || Redmine::AccessControl.read_action?(action)
                   # No write action allowed on closed projects
                   return false
                 end
                 # No action allowed on disabled modules
                 if action.is_a? Hash
                   allowed_actions.include? "#{action[:controller]}/#{action[:action]}"
                 else
                   allowed_permissions.include? action
                 end
               end
               def module_enabled?(module_name)
                 module_name = module_name.to_s
                 enabled_modules.detect {|m| m.name == module_name}
               end
               def enabled_module_names=(module_names)
                 if module_names && module_names.is_a?(Array)
                   module_names = module_names.collect(&:to_s).reject(&:blank?)
                   self.enabled_modules = module_names.collect {|name| enabled_modules.detect {|mod| mod.name == name} || EnabledModule.new(:name => name)}
                 else
                   enabled_modules.clear
                 end
               end
               # Returns an array of the enabled modules names
               def enabled_module_names
                 enabled_modules.collect(&:name)
               end
               # Enable a specific module
               #
               # Examples:
               #   project.enable_module!(:issue_tracking)
               #   project.enable_module!("issue_tracking")
               def enable_module!(name)
                 enabled_modules << EnabledModule.new(:name => name.to_s) unless module_enabled?(name)
               end
               # Disable a module if it exists
               #
               # Examples:
               #   project.disable_module!(:issue_tracking)
               #   project.disable_module!("issue_tracking")
               #   project.disable_module!(project.enabled_modules.first)
               def disable_module!(target)
                 target = enabled_modules.detect{|mod| target.to_s == mod.name} unless enabled_modules.include?(target)
                 target.destroy unless target.blank?
               end
               safe_attributes 'name',
                 'description',
                 'homepage',
                 'is_public',
                 'identifier',
                 'custom_field_values',
                 'custom_fields',
                 'tracker_ids',
                 'issue_custom_field_ids'
               safe_attributes 'enabled_module_names',
                 :if => lambda {|project, user| project.new_record? || user.allowed_to?(:select_project_modules, project) }
               # Returns an array of projects that are in this project's hierarchy
               #
               # Example: parents, children, siblings
               def hierarchy
                 parents = project.self_and_ancestors || []
                 descendants = project.descendants || []
                 project_hierarchy = parents | descendants # Set union
               end
               # Returns an auto-generated project identifier based on the last identifier used
               def self.next_identifier
                 p = Project.order('created_on DESC').first
                 p.nil? ? nil : p.identifier.to_s.succ
               end
               # Copies and saves the Project instance based on the +project+.
               # Duplicates the source project's:
               # * Wiki
               # * Versions
               # * Categories
               # * Issues
               # * Members
               # * Queries
               #
               # Accepts an +options+ argument to specify what to copy
               #
               # Examples:
               #   project.copy(1)                                    # => copies everything
               #   project.copy(1, :only => 'members')                # => copies members only
               #   project.copy(1, :only => ['members', 'versions'])  # => copies members and versions
               def copy(project, options={})
                 project = project.is_a?(Project) ? project : Project.find(project)
                 to_be_copied = %w(wiki versions issue_categories issues members queries boards)
                 to_be_copied = to_be_copied & options[:only].to_a unless options[:only].nil?
                 Project.transaction do
                   if save
                     reload
                     to_be_copied.each do |name|
                       send "copy_#{name}", project
                     end
                     Redmine::Hook.call_hook(:model_project_copy_before_save, :source_project => project, :destination_project => self)
                     save
                   end
                 end
               end
               # Returns a new unsaved Project instance with attributes copied from +project+
               def self.copy_from(project)
                 project = project.is_a?(Project) ? project : Project.find(project)
                 # clear unique attributes
                 attributes = project.attributes.dup.except('id', 'name', 'identifier', 'status', 'parent_id', 'lft', 'rgt')
                 copy = Project.new(attributes)
                 copy.enabled_modules = project.enabled_modules
                 copy.trackers = project.trackers
                 copy.custom_values = project.custom_values.collect {|v| v.clone}
                 copy.issue_custom_fields = project.issue_custom_fields
                 copy
               end
               # Yields the given block for each project with its level in the tree
               def self.project_tree(projects, &block)
                 ancestors = []
                 projects.sort_by(&:lft).each do |project|
                   while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
                     ancestors.pop
                   end
                   yield project, ancestors.size
                   ancestors << project
                 end
               end
               private
               # Copies wiki from +project+
               def copy_wiki(project)
                 # Check that the source project has a wiki first
                 unless project.wiki.nil?
                   self.wiki ||= Wiki.new
                   wiki.attributes = project.wiki.attributes.dup.except("id", "project_id")
                   wiki_pages_map = {}
                   project.wiki.pages.each do |page|
                     # Skip pages without content
                     next if page.content.nil?
                     new_wiki_content = WikiContent.new(page.content.attributes.dup.except("id", "page_id", "updated_on"))
                     new_wiki_page = WikiPage.new(page.attributes.dup.except("id", "wiki_id", "created_on", "parent_id"))
                     new_wiki_page.content = new_wiki_content
                     wiki.pages << new_wiki_page
                     wiki_pages_map[page.id] = new_wiki_page
                   end
                   wiki.save
                   # Reproduce page hierarchy
                   project.wiki.pages.each do |page|
                     if page.parent_id && wiki_pages_map[page.id]
                       wiki_pages_map[page.id].parent = wiki_pages_map[page.parent_id]
                       wiki_pages_map[page.id].save
                     end
                   end
                 end
               end
               # Copies versions from +project+
               def copy_versions(project)
                 project.versions.each do |version|
                   new_version = Version.new
                   new_version.attributes = version.attributes.dup.except("id", "project_id", "created_on", "updated_on")
                   self.versions << new_version
                 end
               end
               # Copies issue categories from +project+
               def copy_issue_categories(project)
                 project.issue_categories.each do |issue_category|
                   new_issue_category = IssueCategory.new
                   new_issue_category.attributes = issue_category.attributes.dup.except("id", "project_id")
                   self.issue_categories << new_issue_category
                 end
               end
               # Copies issues from +project+
               def copy_issues(project)
                 # Stores the source issue id as a key and the copied issues as the
                 # value.  Used to map the two togeather for issue relations.
                 issues_map = {}
                 # Store status and reopen locked/closed versions
                 version_statuses = versions.reject(&:open?).map {|version| [version, version.status]}
                 version_statuses.each do |version, status|
                   version.update_attribute :status, 'open'
                 end
                 # Get issues sorted by root_id, lft so that parent issues
                 # get copied before their children
                 project.issues.reorder('root_id, lft').all.each do |issue|
                   new_issue = Issue.new
                   new_issue.copy_from(issue, :subtasks => false, :link => false)
                   new_issue.project = self
                   # Reassign fixed_versions by name, since names are unique per project
                   if issue.fixed_version && issue.fixed_version.project == project
                     new_issue.fixed_version = self.versions.detect {|v| v.name == issue.fixed_version.name}
                   end
                   # Reassign the category by name, since names are unique per project
                   if issue.category
                     new_issue.category = self.issue_categories.detect {|c| c.name == issue.category.name}
                   end
                   # Parent issue
                   if issue.parent_id
                     if copied_parent = issues_map[issue.parent_id]
                       new_issue.parent_issue_id = copied_parent.id
                     end
                   end
                   self.issues << new_issue
                   if new_issue.new_record?
                     logger.info "Project#copy_issues: issue ##{issue.id} could not be copied: #{new_issue.errors.full_messages}" if logger && logger.info
                   else
                     issues_map[issue.id] = new_issue unless new_issue.new_record?
                   end
                 end
                 # Restore locked/closed version statuses
                 version_statuses.each do |version, status|
                   version.update_attribute :status, status
                 end
                 # Relations after in case issues related each other
                 project.issues.each do |issue|
                   new_issue = issues_map[issue.id]
                   unless new_issue
                     # Issue was not copied
                     next
                   end
                   # Relations
                   issue.relations_from.each do |source_relation|
                     new_issue_relation = IssueRelation.new
                     new_issue_relation.attributes = source_relation.attributes.dup.except("id", "issue_from_id", "issue_to_id")
                     new_issue_relation.issue_to = issues_map[source_relation.issue_to_id]
                     if new_issue_relation.issue_to.nil? && Setting.cross_project_issue_relations?
                       new_issue_relation.issue_to = source_relation.issue_to
                     end
                     new_issue.relations_from << new_issue_relation
                   end
                   issue.relations_to.each do |source_relation|
                     new_issue_relation = IssueRelation.new
                     new_issue_relation.attributes = source_relation.attributes.dup.except("id", "issue_from_id", "issue_to_id")
                     new_issue_relation.issue_from = issues_map[source_relation.issue_from_id]
                     if new_issue_relation.issue_from.nil? && Setting.cross_project_issue_relations?
                       new_issue_relation.issue_from = source_relation.issue_from
                     end
                     new_issue.relations_to << new_issue_relation
                   end
                 end
               end
               # Copies members from +project+
               def copy_members(project)
                 # Copy users first, then groups to handle members with inherited and given roles
                 members_to_copy = []
                 members_to_copy += project.memberships.select {|m| m.principal.is_a?(User)}
                 members_to_copy += project.memberships.select {|m| !m.principal.is_a?(User)}
                 members_to_copy.each do |member|
                   new_member = Member.new
                   new_member.attributes = member.attributes.dup.except("id", "project_id", "created_on")
                   # only copy non inherited roles
                   # inherited roles will be added when copying the group membership
                   role_ids = member.member_roles.reject(&:inherited?).collect(&:role_id)
                   next if role_ids.empty?
                   new_member.role_ids = role_ids
                   new_member.project = self
                   self.members << new_member
                 end
               end
               # Copies queries from +project+
               def copy_queries(project)
                 project.queries.each do |query|
-                  new_query = ::Query.new
+                  new_query = IssueQuery.new
                   new_query.attributes = query.attributes.dup.except("id", "project_id", "sort_criteria")
                   new_query.sort_criteria = query.sort_criteria if query.sort_criteria
                   new_query.project = self
                   new_query.user_id = query.user_id
                   self.queries << new_query
                 end
               end
               # Copies boards from +project+
               def copy_boards(project)
                 project.boards.each do |board|
                   new_board = Board.new
                   new_board.attributes = board.attributes.dup.except("id", "project_id", "topics_count", "messages_count", "last_message_id")
                   new_board.project = self
                   self.boards << new_board
                 end
               end
               def allowed_permissions
                 @allowed_permissions ||= begin
                   module_names = enabled_modules.all(:select => :name).collect {|m| m.name}
                   Redmine::AccessControl.modules_permissions(module_names).collect {|p| p.name}
                 end
               end
               def allowed_actions
                 @actions_allowed ||= allowed_permissions.inject([]) { |actions, permission| actions += Redmine::AccessControl.allowed_actions(permission) }.flatten
               end
               # Returns all the active Systemwide and project specific activities
               def active_activities
                 overridden_activity_ids = self.time_entry_activities.collect(&:parent_id)
                 if overridden_activity_ids.empty?
                   return TimeEntryActivity.shared.active
                 else
                   return system_activities_and_project_overrides
                 end
               end
               # Returns all the Systemwide and project specific activities
               # (inactive and active)
               def all_activities
                 overridden_activity_ids = self.time_entry_activities.collect(&:parent_id)
                 if overridden_activity_ids.empty?
                   return TimeEntryActivity.shared
                 else
                   return system_activities_and_project_overrides(true)
                 end
               end
               # Returns the systemwide active activities merged with the project specific overrides
               def system_activities_and_project_overrides(include_inactive=false)
                 if include_inactive
                   return TimeEntryActivity.shared.
                     where("id NOT IN (?)", self.time_entry_activities.collect(&:parent_id)).all +
                     self.time_entry_activities
                 else
                   return TimeEntryActivity.shared.active.
                     where("id NOT IN (?)", self.time_entry_activities.collect(&:parent_id)).all +
                     self.time_entry_activities.active
                 end
               end
               # Archives subprojects recursively
               def archive!
                 children.each do |subproject|
                   subproject.send :archive!
                 end
                 update_attribute :status, STATUS_ARCHIVED
               end
               def update_position_under_parent
                 set_or_update_position_under(parent)
               end
               # Inserts/moves the project so that target's children or root projects stay alphabetically sorted
               def set_or_update_position_under(target_parent)
                 sibs = (target_parent.nil? ? self.class.roots : target_parent.children)
                 to_be_inserted_before = sibs.sort_by {|c| c.name.to_s.downcase}.detect {|c| c.name.to_s.downcase > name.to_s.downcase }
                 if to_be_inserted_before
                   move_to_left_of(to_be_inserted_before)
                 elsif target_parent.nil?
                   if sibs.empty?
                     # move_to_root adds the project in first (ie. left) position
                     move_to_root
                   else
                     move_to_right_of(sibs.last) unless self == sibs.last
                   end
                 else
                   # move_to_child_of adds the project in last (ie.right) position
                   move_to_child_of(target_parent)
                 end
               end
             end

app/models/query.rb +1 -297

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 QueryColumn
               attr_accessor :name, :sortable, :groupable, :default_order
               include Redmine::I18n
               def initialize(name, options={})
                 self.name = name
                 self.sortable = options[:sortable]
                 self.groupable = options[:groupable] || false
                 if groupable == true
                   self.groupable = name.to_s
                 end
                 self.default_order = options[:default_order]
                 @inline = options.key?(:inline) ? options[:inline] : true
                 @caption_key = options[:caption] || "field_#{name}"
               end
               def caption
                 l(@caption_key)
               end
               # Returns true if the column is sortable, otherwise false
               def sortable?
                 !@sortable.nil?
               end
               def sortable
                 @sortable.is_a?(Proc) ? @sortable.call : @sortable
               end
               def inline?
                 @inline
               end
               def value(issue)
                 issue.send name
               end
               def css_classes
                 name
               end
             end
             class QueryCustomFieldColumn < QueryColumn
               def initialize(custom_field)
                 self.name = "cf_#{custom_field.id}".to_sym
                 self.sortable = custom_field.order_statement || false
                 self.groupable = custom_field.group_statement || false
                 @inline = true
                 @cf = custom_field
               end
               def caption
                 @cf.name
               end
               def custom_field
                 @cf
               end
               def value(issue)
                 cv = issue.custom_values.select {|v| v.custom_field_id == @cf.id}.collect {|v| @cf.cast_value(v.value)}
                 cv.size > 1 ? cv.sort {|a,b| a.to_s <=> b.to_s} : cv.first
               end
               def css_classes
                 @css_classes ||= "#{name} #{@cf.field_format}"
               end
             end
             class Query < ActiveRecord::Base
               class StatementInvalid < ::ActiveRecord::StatementInvalid
               end
               belongs_to :project
               belongs_to :user
               serialize :filters
               serialize :column_names
               serialize :sort_criteria, Array
               attr_protected :project_id, :user_id
               validates_presence_of :name
               validates_length_of :name, :maximum => 255
               validate :validate_query_filters
               class_attribute :operators
               self.operators = {
                 "="   => :label_equals,
                 "!"   => :label_not_equals,
                 "o"   => :label_open_issues,
                 "c"   => :label_closed_issues,
                 "!*"  => :label_none,
                 "*"   => :label_any,
                 ">="  => :label_greater_or_equal,
                 "<="  => :label_less_or_equal,
                 "><"  => :label_between,
                 "<t+" => :label_in_less_than,
                 ">t+" => :label_in_more_than,
                 "><t+"=> :label_in_the_next_days,
                 "t+"  => :label_in,
                 "t"   => :label_today,
                 "w"   => :label_this_week,
                 ">t-" => :label_less_than_ago,
                 "<t-" => :label_more_than_ago,
                 "><t-"=> :label_in_the_past_days,
                 "t-"  => :label_ago,
                 "~"   => :label_contains,
                 "!~"  => :label_not_contains,
                 "=p"  => :label_any_issues_in_project,
                 "=!p" => :label_any_issues_not_in_project,
                 "!p"  => :label_no_issues_in_project
               }
               class_attribute :operators_by_filter_type
               self.operators_by_filter_type = {
                 :list => [ "=", "!" ],
                 :list_status => [ "o", "=", "!", "c", "*" ],
                 :list_optional => [ "=", "!", "!*", "*" ],
                 :list_subprojects => [ "*", "!*", "=" ],
                 :date => [ "=", ">=", "<=", "><", "<t+", ">t+", "><t+", "t+", "t", "w", ">t-", "<t-", "><t-", "t-", "!*", "*" ],
                 :date_past => [ "=", ">=", "<=", "><", ">t-", "<t-", "><t-", "t-", "t", "w", "!*", "*" ],
                 :string => [ "=", "~", "!", "!~", "!*", "*" ],
                 :text => [  "~", "!~", "!*", "*" ],
                 :integer => [ "=", ">=", "<=", "><", "!*", "*" ],
                 :float => [ "=", ">=", "<=", "><", "!*", "*" ],
                 :relation => ["=", "=p", "=!p", "!p", "!*", "*"]
               }
               class_attribute :available_columns
-              self.available_columns = [
+              self.available_columns = []
-                QueryColumn.new(:project, :sortable => "#{Project.table_name}.name", :groupable => true),
-                QueryColumn.new(:tracker, :sortable => "#{Tracker.table_name}.position", :groupable => true),
-                QueryColumn.new(:parent, :sortable => ["#{Issue.table_name}.root_id", "#{Issue.table_name}.lft ASC"], :default_order => 'desc', :caption => :field_parent_issue),
-                QueryColumn.new(:status, :sortable => "#{IssueStatus.table_name}.position", :groupable => true),
-                QueryColumn.new(:priority, :sortable => "#{IssuePriority.table_name}.position", :default_order => 'desc', :groupable => true),
-                QueryColumn.new(:subject, :sortable => "#{Issue.table_name}.subject"),
-                QueryColumn.new(:author, :sortable => lambda {User.fields_for_order_statement("authors")}, :groupable => true),
-                QueryColumn.new(:assigned_to, :sortable => lambda {User.fields_for_order_statement}, :groupable => true),
-                QueryColumn.new(:updated_on, :sortable => "#{Issue.table_name}.updated_on", :default_order => 'desc'),
-                QueryColumn.new(:category, :sortable => "#{IssueCategory.table_name}.name", :groupable => true),
-                QueryColumn.new(:fixed_version, :sortable => lambda {Version.fields_for_order_statement}, :groupable => true),
-                QueryColumn.new(:start_date, :sortable => "#{Issue.table_name}.start_date"),
-                QueryColumn.new(:due_date, :sortable => "#{Issue.table_name}.due_date"),
-                QueryColumn.new(:estimated_hours, :sortable => "#{Issue.table_name}.estimated_hours"),
-                QueryColumn.new(:done_ratio, :sortable => "#{Issue.table_name}.done_ratio", :groupable => true),
-                QueryColumn.new(:created_on, :sortable => "#{Issue.table_name}.created_on", :default_order => 'desc'),
-                QueryColumn.new(:relations, :caption => :label_related_issues),
-                QueryColumn.new(:description, :inline => false)
-              scope :visible, lambda {|*args|
-                user = args.shift || User.current
-                base = Project.allowed_to_condition(user, :view_issues, *args)
-                user_id = user.logged? ? user.id : 0
-                includes(:project).where("(#{table_name}.project_id IS NULL OR (#{base})) AND (#{table_name}.is_public = ? OR #{table_name}.user_id = ?)", true, user_id)
               def initialize(attributes=nil, *args)
                 super attributes
-                self.filters ||= { 'status_id' => {:operator => "o", :values => [""]} }
                 @is_for_all = project.nil?
               end
               def validate_query_filters
                 filters.each_key do |field|
                   if values_for(field)
                     case type_for(field)
                     when :integer
                       add_filter_error(field, :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^[+-]?\d+$/) }
                     when :float
                       add_filter_error(field, :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^[+-]?\d+(\.\d*)?$/) }
                     when :date, :date_past
                       case operator_for(field)
                       when "=", ">=", "<=", "><"
                         add_filter_error(field, :invalid) if values_for(field).detect {|v| v.present? && (!v.match(/^\d{4}-\d{2}-\d{2}$/) || (Date.parse(v) rescue nil).nil?) }
                       when ">t-", "<t-", "t-", ">t+", "<t+", "t+", "><t+", "><t-"
                         add_filter_error(field, :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^\d+$/) }
                       end
                     end
                   end
                   add_filter_error(field, :blank) unless
                       # filter requires one or more values
                       (values_for(field) and !values_for(field).first.blank?) or
                       # filter doesn't require any value
                       ["o", "c", "!*", "*", "t", "w"].include? operator_for(field)
                 end if filters
               end
               def add_filter_error(field, message)
                 m = label_for(field) + " " + l(message, :scope => 'activerecord.errors.messages')
                 errors.add(:base, m)
               end
-              # Returns true if the query is visible to +user+ or the current user.
-              def visible?(user=User.current)
-                (project.nil? || user.allowed_to?(:view_issues, project)) && (self.is_public? || self.user_id == user.id)
-              end
               def editable_by?(user)
                 return false unless user
                 # Admin can edit them all and regular users can edit their private queries
                 return true if user.admin? || (!is_public && self.user_id == user.id)
                 # Members can not edit public queries that are for all project (only admin is allowed to)
                 is_public && !@is_for_all && user.allowed_to?(:manage_public_queries, project)
               end
               def trackers
                 @trackers ||= project.nil? ? Tracker.sorted.all : project.rolled_up_trackers
               end
               # Returns a hash of localized labels for all filter operators
               def self.operators_labels
                 operators.inject({}) {|h, operator| h[operator.first] = l(operator.last); h}
               end
-              def available_filters
-                return @available_filters if @available_filters
-                @available_filters = {
-                  "status_id" => {
-                    :type => :list_status, :order => 0,
-                    :values => IssueStatus.sorted.all.collect{|s| [s.name, s.id.to_s] }
-                   },
-                  "tracker_id" => {
-                    :type => :list, :order => 2, :values => trackers.collect{|s| [s.name, s.id.to_s] }
-                   },
-                  "priority_id" => {
-                    :type => :list, :order => 3, :values => IssuePriority.all.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 },
-                  "estimated_hours" => { :type => :float, :order => 13 },
-                  "done_ratio" =>  { :type => :integer, :order => 14 }
-                IssueRelation::TYPES.each do |relation_type, options|
-                  @available_filters[relation_type] = {
-                    :type => :relation, :order => @available_filters.size + 100,
-                    :label => options[:name]
-                end
-                principals = []
-                if project
-                  principals += project.principals.sort
-                  unless project.leaf?
-                    subprojects = project.descendants.visible.all
-                    if subprojects.any?
-                      @available_filters["subproject_id"] = {
-                        :type => :list_subprojects, :order => 13,
-                        :values => subprojects.collect{|s| [s.name, s.id.to_s] }
-                      principals += Principal.member_of(subprojects)
-                    end
-                  end
-                else
-                  if all_projects.any?
-                    # members of visible projects
-                    principals += Principal.member_of(all_projects)
-                    # project filter
-                    project_values = []
-                    if User.current.logged? && User.current.memberships.any?
-                      project_values << ["<< #{l(:label_my_projects).downcase} >>", "mine"]
-                    end
-                    project_values += all_projects_values
-                    @available_filters["project_id"] = {
-                      :type => :list, :order => 1, :values => project_values
-                    } unless project_values.empty?
-                  end
-                end
-                principals.uniq!
-                principals.sort!
-                users = principals.select {|p| p.is_a?(User)}
-                assigned_to_values = []
-                assigned_to_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?
-                assigned_to_values += (Setting.issue_group_assignment? ?
-                                          principals : users).collect{|s| [s.name, s.id.to_s] }
-                @available_filters["assigned_to_id"] = {
-                  :type => :list_optional, :order => 4, :values => assigned_to_values
-                } unless assigned_to_values.empty?
-                author_values = []
-                author_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?
-                author_values += users.collect{|s| [s.name, s.id.to_s] }
-                @available_filters["author_id"] = {
-                  :type => :list, :order => 5, :values => author_values
-                } unless author_values.empty?
-                group_values = Group.all.collect {|g| [g.name, g.id.to_s] }
-                @available_filters["member_of_group"] = {
-                  :type => :list_optional, :order => 6, :values => group_values
-                } unless group_values.empty?
-                role_values = Role.givable.collect {|r| [r.name, r.id.to_s] }
-                @available_filters["assigned_to_role"] = {
-                  :type => :list_optional, :order => 7, :values => role_values
-                } unless role_values.empty?
-                if User.current.logged?
-                  @available_filters["watcher_id"] = {
-                    :type => :list, :order => 15, :values => [["<< #{l(:label_me)} >>", "me"]]
-                end
-                if project
-                  # project specific filters
-                  categories = project.issue_categories.all
-                  unless categories.empty?
-                    @available_filters["category_id"] = {
-                      :type => :list_optional, :order => 6,
-                      :values => categories.collect{|s| [s.name, s.id.to_s] }
-                  end
-                  versions = project.shared_versions.all
-                  unless versions.empty?
-                    @available_filters["fixed_version_id"] = {
-                      :type => :list_optional, :order => 7,
-                      :values => versions.sort.collect{|s| ["#{s.project.name} - #{s.name}", s.id.to_s] }
-                  end
-                  add_custom_fields_filters(project.all_issue_custom_fields)
-                else
-                  # global filters for cross project issue list
-                  system_shared_versions = Version.visible.find_all_by_sharing('system')
-                  unless system_shared_versions.empty?
-                    @available_filters["fixed_version_id"] = {
-                      :type => :list_optional, :order => 7,
-                      :values => system_shared_versions.sort.collect{|s|
-                                                   ["#{s.project.name} - #{s.name}", s.id.to_s]
-                  end
-                  add_custom_fields_filters(IssueCustomField.where(:is_filter => true, :is_for_all => true).all)
-                end
-                add_associations_custom_fields_filters :project, :author, :assigned_to, :fixed_version
-                if User.current.allowed_to?(:set_issues_private, nil, :global => true) ||
-                  User.current.allowed_to?(:set_own_issues_private, nil, :global => true)
-                  @available_filters["is_private"] = {
-                    :type => :list, :order => 16,
-                    :values => [[l(:general_text_yes), "1"], [l(:general_text_no), "0"]]
-                end
-                Tracker.disabled_core_fields(trackers).each {|field|
-                  @available_filters.delete field
-                @available_filters.each do |field, options|
-                  options[:name] ||= l(options[:label] || "field_#{field}".gsub(/_id$/, ''))
-                end
-                @available_filters
-              end
               # Returns a representation of the available filters for JSON serialization
               def available_filters_as_json
                 json = {}
                 available_filters.each do |field, options|
                   json[field] = options.slice(:type, :name, :values).stringify_keys
                 end
                 json
               end
               def all_projects
                 @all_projects ||= Project.visible.all
               end
               def all_projects_values
                 return @all_projects_values if @all_projects_values
                 values = []
                 Project.project_tree(all_projects) do |p, level|
                   prefix = (level > 0 ? ('--' * level + ' ') : '')
                   values << ["#{prefix}#{p.name}", p.id.to_s]
                 end
                 @all_projects_values = values
               end
               def add_filter(field, operator, values)
                 # values must be an array
                 return unless values.nil? || values.is_a?(Array)
                 # check if field is defined as an available filter
                 if available_filters.has_key? field
                   filter_options = available_filters[field]
                   filters[field] = {:operator => operator, :values => (values || [''])}
                 end
               end
               def add_short_filter(field, expression)
                 return unless expression && available_filters.has_key?(field)
                 field_type = available_filters[field][:type]
                 operators_by_filter_type[field_type].sort.reverse.detect do |operator|
                   next unless expression =~ /^#{Regexp.escape(operator)}(.*)$/
                   add_filter field, operator, $1.present? ? $1.split('|') : ['']
                 end || add_filter(field, '=', expression.split('|'))
               end
               # Add multiple filters using +add_filter+
               def add_filters(fields, operators, values)
                 if fields.is_a?(Array) && operators.is_a?(Hash) && (values.nil? || values.is_a?(Hash))
                   fields.each do |field|
                     add_filter(field, operators[field], values && values[field])
                   end
                 end
               end
               def has_filter?(field)
                 filters and filters[field]
               end
               def type_for(field)
                 available_filters[field][:type] if available_filters.has_key?(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 value_for(field, index=0)
                 (values_for(field) || [])[index]
               end
               def label_for(field)
                 label = available_filters[field][:name] if available_filters.has_key?(field)
                 label ||= l("field_#{field.to_s.gsub(/_id$/, '')}", :default => field)
               end
-              def available_columns
-                return @available_columns if @available_columns
-                @available_columns = ::Query.available_columns.dup
-                @available_columns += (project ?
-                                        project.all_issue_custom_fields :
-                                        IssueCustomField.all
-                                       ).collect {|cf| QueryCustomFieldColumn.new(cf) }
-                if User.current.allowed_to?(:view_time_entries, project, :global => true)
-                  index = nil
-                  @available_columns.each_with_index {|column, i| index = i if column.name == :estimated_hours}
-                  index = (index ? index + 1 : -1)
-                  # insert the column after estimated_hours or at the end
-                  @available_columns.insert index, QueryColumn.new(:spent_hours,
-                    :sortable => "(SELECT COALESCE(SUM(hours), 0) FROM #{TimeEntry.table_name} WHERE #{TimeEntry.table_name}.issue_id = #{Issue.table_name}.id)",
-                    :default_order => 'desc',
-                    :caption => :label_spent_time
-                end
-                if User.current.allowed_to?(:set_issues_private, nil, :global => true) ||
-                  User.current.allowed_to?(:set_own_issues_private, nil, :global => true)
-                  @available_columns << QueryColumn.new(:is_private, :sortable => "#{Issue.table_name}.is_private")
-                end
-                disabled_fields = Tracker.disabled_core_fields(trackers).map {|field| field.sub(/_id$/, '')}
-                @available_columns.reject! {|column|
-                  disabled_fields.include?(column.name.to_s)
-                @available_columns
-              end
               def self.add_available_column(column)
                 self.available_columns << (column) if column.is_a?(QueryColumn)
               end
               # Returns an array of columns that can be used to group the results
               def groupable_columns
                 available_columns.select {|c| c.groupable}
               end
               # Returns a Hash of columns and the key for sorting
               def sortable_columns
                 {'id' => "#{Issue.table_name}.id"}.merge(available_columns.inject({}) {|h, column|
                                                            h[column.name.to_s] = column.sortable
                                                            h
                                                          })
               end
               def columns
                 # preserve the column_names order
                 (has_default_columns? ? default_columns_names : column_names).collect do |name|
                    available_columns.find { |col| col.name == name }
                 end.compact
               end
               def inline_columns
                 columns.select(&:inline?)
               end
               def block_columns
                 columns.reject(&:inline?)
               end
               def available_inline_columns
                 available_columns.select(&:inline?)
               end
               def available_block_columns
                 available_columns.reject(&:inline?)
               end
               def default_columns_names
                 @default_columns_names ||= begin
                   default_columns = Setting.issue_list_default_columns.map(&:to_sym)
                   project.present? ? default_columns : [:project] | default_columns
                 end
               end
               def column_names=(names)
                 if names
                   names = names.select {|n| n.is_a?(Symbol) || !n.blank? }
                   names = names.collect {|n| n.is_a?(Symbol) ? n : n.to_sym }
                   # Set column_names to nil if default columns
                   if names == default_columns_names
                     names = nil
                   end
                 end
                 write_attribute(:column_names, names)
               end
               def has_column?(column)
                 column_names && column_names.include?(column.is_a?(QueryColumn) ? column.name : column)
               end
               def has_default_columns?
                 column_names.nil? || column_names.empty?
               end
               def sort_criteria=(arg)
                 c = []
                 if arg.is_a?(Hash)
                   arg = arg.keys.sort.collect {|k| arg[k]}
                 end
                 c = arg.select {|k,o| !k.to_s.blank?}.slice(0,3).collect {|k,o| [k.to_s, (o == 'desc' || o == false) ? 'desc' : 'asc']}
                 write_attribute(:sort_criteria, c)
               end
               def sort_criteria
                 read_attribute(:sort_criteria) || []
               end
               def sort_criteria_key(arg)
                 sort_criteria && sort_criteria[arg] && sort_criteria[arg].first
               end
               def sort_criteria_order(arg)
                 sort_criteria && sort_criteria[arg] && sort_criteria[arg].last
               end
               def sort_criteria_order_for(key)
                 sort_criteria.detect {|k, order| key.to_s == k}.try(:last)
               end
               # Returns the SQL sort order that should be prepended for grouping
               def group_by_sort_order
                 if grouped? && (column = group_by_column)
                   order = sort_criteria_order_for(column.name) || column.default_order
                   column.sortable.is_a?(Array) ?
                     column.sortable.collect {|s| "#{s} #{order}"}.join(',') :
                     "#{column.sortable} #{order}"
                 end
               end
               # Returns true if the query is a grouped query
               def grouped?
                 !group_by_column.nil?
               end
               def group_by_column
                 groupable_columns.detect {|c| c.groupable && c.name.to_s == group_by}
               end
               def group_by_statement
                 group_by_column.try(:groupable)
               end
               def project_statement
                 project_clauses = []
                 if project && !project.descendants.active.empty?
                   ids = [project.id]
                   if has_filter?("subproject_id")
                     case operator_for("subproject_id")
                     when '='
                       # include the selected subprojects
                       ids += values_for("subproject_id").each(&:to_i)
                     when '!*'
                       # main project only
                     else
                       # all subprojects
                       ids += project.descendants.collect(&:id)
                     end
                   elsif Setting.display_subprojects_issues?
                     ids += project.descendants.collect(&:id)
                   end
                   project_clauses << "#{Project.table_name}.id IN (%s)" % ids.join(',')
                 elsif project
                   project_clauses << "#{Project.table_name}.id = %d" % project.id
                 end
                 project_clauses.any? ? project_clauses.join(' AND ') : nil
               end
               def statement
                 # 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?
                   operator = operator_for(field)
                   # "me" value subsitution
                   if %w(assigned_to_id author_id watcher_id).include?(field)
                     if v.delete("me")
                       if User.current.logged?
                         v.push(User.current.id.to_s)
                         v += User.current.group_ids.map(&:to_s) if field == 'assigned_to_id'
                       else
                         v.push("0")
                       end
                     end
                   end
                   if field == 'project_id'
                     if v.delete('mine')
                       v += User.current.memberships.map(&:project_id).map(&:to_s)
                     end
                   end
                   if field =~ /cf_(\d+)$/
                     # custom field
                     filters_clauses << sql_for_custom_field(field, operator, v, $1)
                   elsif respond_to?("sql_for_#{field}_field")
                     # specific statement
                     filters_clauses << send("sql_for_#{field}_field", field, operator, v)
                   else
                     # regular field
                     filters_clauses << '(' + sql_for_field(field, operator, v, Issue.table_name, field) + ')'
                   end
                 end if filters and valid?
                 filters_clauses << project_statement
                 filters_clauses.reject!(&:blank?)
                 filters_clauses.any? ? filters_clauses.join(' AND ') : nil
               end
-              # Returns the issue count
-              def issue_count
-                Issue.visible.count(:include => [:status, :project], :conditions => statement)
-              rescue ::ActiveRecord::StatementInvalid => e
-                raise StatementInvalid.new(e.message)
-              end
-              # Returns the issue count by group or nil if query is not grouped
-              def issue_count_by_group
-                r = nil
-                if grouped?
-                  begin
-                    # Rails3 will raise an (unexpected) RecordNotFound if there's only a nil group value
-                    r = Issue.visible.count(:group => group_by_statement, :include => [:status, :project], :conditions => statement)
-                  rescue ActiveRecord::RecordNotFound
-                    r = {nil => issue_count}
-                  end
-                  c = group_by_column
-                  if c.is_a?(QueryCustomFieldColumn)
-                    r = r.keys.inject({}) {|h, k| h[c.custom_field.cast_value(k)] = r[k]; h}
-                  end
-                end
-              rescue ::ActiveRecord::StatementInvalid => e
-                raise StatementInvalid.new(e.message)
-              end
-              # Returns the issues
-              # Valid options are :order, :offset, :limit, :include, :conditions
-              def issues(options={})
-                order_option = [group_by_sort_order, options[:order]].reject {|s| s.blank?}.join(',')
-                order_option = nil if order_option.blank?
-                issues = Issue.visible.where(options[:conditions]).all(
-                  :include => ([:status, :project] + (options[:include] || [])).uniq,
-                  :conditions => statement,
-                  :order => order_option,
-                  :joins => joins_for_order_statement(order_option),
-                  :limit  => options[:limit],
-                  :offset => options[:offset]
-                if has_column?(:spent_hours)
-                  Issue.load_visible_spent_hours(issues)
-                end
-                if has_column?(:relations)
-                  Issue.load_visible_relations(issues)
-                end
-                issues
-              rescue ::ActiveRecord::StatementInvalid => e
-                raise StatementInvalid.new(e.message)
-              end
-              # Returns the issues ids
-              def issue_ids(options={})
-                order_option = [group_by_sort_order, options[:order]].reject {|s| s.blank?}.join(',')
-                order_option = nil if order_option.blank?
-                Issue.visible.scoped(:conditions => options[:conditions]).scoped(:include => ([:status, :project] + (options[:include] || [])).uniq,
-                                 :conditions => statement,
-                                 :order => order_option,
-                                 :joins => joins_for_order_statement(order_option),
-                                 :limit  => options[:limit],
-                                 :offset => options[:offset]).find_ids
-              rescue ::ActiveRecord::StatementInvalid => e
-                raise StatementInvalid.new(e.message)
-              end
-              # Returns the journals
-              # Valid options are :order, :offset, :limit
-              def journals(options={})
-                Journal.visible.all(
-                  :include => [:details, :user, {:issue => [:project, :author, :tracker, :status]}],
-                  :conditions => statement,
-                  :order => options[:order],
-                  :limit => options[:limit],
-                  :offset => options[:offset]
-              rescue ::ActiveRecord::StatementInvalid => e
-                raise StatementInvalid.new(e.message)
-              end
-              # Returns the versions
-              # Valid options are :conditions
-              def versions(options={})
-                Version.visible.where(options[:conditions]).all(
-                  :include => :project,
-                  :conditions => project_statement
-              rescue ::ActiveRecord::StatementInvalid => e
-                raise StatementInvalid.new(e.message)
-              end
               def sql_for_watcher_id_field(field, operator, value)
                 db_table = Watcher.table_name
                 "#{Issue.table_name}.id #{ operator == '=' ? 'IN' : 'NOT IN' } (SELECT #{db_table}.watchable_id FROM #{db_table} WHERE #{db_table}.watchable_type='Issue' AND " +
                   sql_for_field(field, '=', value, db_table, 'user_id') + ')'
               end
               def sql_for_member_of_group_field(field, operator, value)
                 if operator == '*' # Any group
                   groups = Group.all
                   operator = '=' # Override the operator since we want to find by assigned_to
                 elsif operator == "!*"
                   groups = Group.all
                   operator = '!' # Override the operator since we want to find by assigned_to
                 else
                   groups = Group.find_all_by_id(value)
                 end
                 groups ||= []
                 members_of_groups = groups.inject([]) {|user_ids, group|
                   if group && group.user_ids.present?
                     user_ids << group.user_ids
                   end
                   user_ids.flatten.uniq.compact
                 }.sort.collect(&:to_s)
                 '(' + sql_for_field("assigned_to_id", operator, members_of_groups, Issue.table_name, "assigned_to_id", false) + ')'
               end
               def sql_for_assigned_to_role_field(field, operator, value)
                 case operator
                 when "*", "!*" # Member / Not member
                   sw = operator == "!*" ? 'NOT' : ''
                   nl = operator == "!*" ? "#{Issue.table_name}.assigned_to_id IS NULL OR" : ''
                   "(#{nl} #{Issue.table_name}.assigned_to_id #{sw} IN (SELECT DISTINCT #{Member.table_name}.user_id FROM #{Member.table_name}" +
                     " WHERE #{Member.table_name}.project_id = #{Issue.table_name}.project_id))"
                 when "=", "!"
                   role_cond = value.any? ?
                     "#{MemberRole.table_name}.role_id IN (" + value.collect{|val| "'#{connection.quote_string(val)}'"}.join(",") + ")" :
                     "1=0"
                   sw = operator == "!" ? 'NOT' : ''
                   nl = operator == "!" ? "#{Issue.table_name}.assigned_to_id IS NULL OR" : ''
                   "(#{nl} #{Issue.table_name}.assigned_to_id #{sw} IN (SELECT DISTINCT #{Member.table_name}.user_id FROM #{Member.table_name}, #{MemberRole.table_name}" +
                     " WHERE #{Member.table_name}.project_id = #{Issue.table_name}.project_id AND #{Member.table_name}.id = #{MemberRole.table_name}.member_id AND #{role_cond}))"
                 end
               end
               def sql_for_is_private_field(field, operator, value)
                 op = (operator == "=" ? 'IN' : 'NOT IN')
                 va = value.map {|v| v == '0' ? connection.quoted_false : connection.quoted_true}.uniq.join(',')
                 "#{Issue.table_name}.is_private #{op} (#{va})"
               end
               def sql_for_relations(field, operator, value, options={})
                 relation_options = IssueRelation::TYPES[field]
                 return relation_options unless relation_options
                 relation_type = field
                 join_column, target_join_column = "issue_from_id", "issue_to_id"
                 if relation_options[:reverse] || options[:reverse]
                   relation_type = relation_options[:reverse] || relation_type
                   join_column, target_join_column = target_join_column, join_column
                 end
                 sql = case operator
                   when "*", "!*"
                     op = (operator == "*" ? 'IN' : 'NOT IN')
                     "#{Issue.table_name}.id #{op} (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name} WHERE #{IssueRelation.table_name}.relation_type = '#{connection.quote_string(relation_type)}')"
                   when "=", "!"
                     op = (operator == "=" ? 'IN' : 'NOT IN')
                     "#{Issue.table_name}.id #{op} (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name} WHERE #{IssueRelation.table_name}.relation_type = '#{connection.quote_string(relation_type)}' AND #{IssueRelation.table_name}.#{target_join_column} = #{value.first.to_i})"
                   when "=p", "=!p", "!p"
                     op = (operator == "!p" ? 'NOT IN' : 'IN')
                     comp = (operator == "=!p" ? '<>' : '=')
                     "#{Issue.table_name}.id #{op} (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name}, #{Issue.table_name} relissues WHERE #{IssueRelation.table_name}.relation_type = '#{connection.quote_string(relation_type)}' AND #{IssueRelation.table_name}.#{target_join_column} = relissues.id AND relissues.project_id #{comp} #{value.first.to_i})"
                   end
                 if relation_options[:sym] == field && !options[:reverse]
                   sqls = [sql, sql_for_relations(field, operator, value, :reverse => true)]
                   sqls.join(["!", "!*", "!p"].include?(operator) ? " AND " : " OR ")
                 else
                   sql
                 end
               end
               IssueRelation::TYPES.keys.each do |relation_type|
                 alias_method "sql_for_#{relation_type}_field".to_sym, :sql_for_relations
               end
               private
               def sql_for_custom_field(field, operator, value, custom_field_id)
                 db_table = CustomValue.table_name
                 db_field = 'value'
                 filter = @available_filters[field]
                 return nil unless filter
                 if filter[:format] == 'user'
                   if value.delete('me')
                     value.push User.current.id.to_s
                   end
                 end
                 not_in = nil
                 if operator == '!'
                   # Makes ! operator work for custom fields with multiple values
                   operator = '='
                   not_in = 'NOT'
                 end
                 customized_key = "id"
                 customized_class = Issue
                 if field =~ /^(.+)\.cf_/
                   assoc = $1
                   customized_key = "#{assoc}_id"
                   customized_class = Issue.reflect_on_association(assoc.to_sym).klass.base_class rescue nil
                   raise "Unknown Issue association #{assoc}" unless customized_class
                 end
                 "#{Issue.table_name}.#{customized_key} #{not_in} IN (SELECT #{customized_class.table_name}.id FROM #{customized_class.table_name} LEFT OUTER JOIN #{db_table} ON #{db_table}.customized_type='#{customized_class}' AND #{db_table}.customized_id=#{customized_class.table_name}.id AND #{db_table}.custom_field_id=#{custom_field_id} WHERE " +
                   sql_for_field(field, operator, value, db_table, db_field, true) + ')'
               end
               # Helper method to generate the WHERE sql for a +field+, +operator+ and a +value+
               def sql_for_field(field, operator, value, db_table, db_field, is_custom_filter=false)
                 sql = ''
                 case operator
                 when "="
                   if value.any?
                     case type_for(field)
                     when :date, :date_past
                       sql = date_clause(db_table, db_field, (Date.parse(value.first) rescue nil), (Date.parse(value.first) rescue nil))
                     when :integer
                       if is_custom_filter
                         sql = "(#{db_table}.#{db_field} <> '' AND CAST(#{db_table}.#{db_field} AS decimal(60,3)) = #{value.first.to_i})"
                       else
                         sql = "#{db_table}.#{db_field} = #{value.first.to_i}"
                       end
                     when :float
                       if is_custom_filter
                         sql = "(#{db_table}.#{db_field} <> '' AND CAST(#{db_table}.#{db_field} AS decimal(60,3)) BETWEEN #{value.first.to_f - 1e-5} AND #{value.first.to_f + 1e-5})"
                       else
                         sql = "#{db_table}.#{db_field} BETWEEN #{value.first.to_f - 1e-5} AND #{value.first.to_f + 1e-5}"
                       end
                     else
                       sql = "#{db_table}.#{db_field} IN (" + value.collect{|val| "'#{connection.quote_string(val)}'"}.join(",") + ")"
                     end
                   else
                     # IN an empty set
                     sql = "1=0"
                   end
                 when "!"
                   if value.any?
                     sql = "(#{db_table}.#{db_field} IS NULL OR #{db_table}.#{db_field} NOT IN (" + value.collect{|val| "'#{connection.quote_string(val)}'"}.join(",") + "))"
                   else
                     # NOT IN an empty set
                     sql = "1=1"
                   end
                 when "!*"
                   sql = "#{db_table}.#{db_field} IS NULL"
                   sql << " OR #{db_table}.#{db_field} = ''" if is_custom_filter
                 when "*"
                   sql = "#{db_table}.#{db_field} IS NOT NULL"
                   sql << " AND #{db_table}.#{db_field} <> ''" if is_custom_filter
                 when ">="
                   if [:date, :date_past].include?(type_for(field))
                     sql = date_clause(db_table, db_field, (Date.parse(value.first) rescue nil), nil)
                   else
                     if is_custom_filter
                       sql = "(#{db_table}.#{db_field} <> '' AND CAST(#{db_table}.#{db_field} AS decimal(60,3)) >= #{value.first.to_f})"
                     else
                       sql = "#{db_table}.#{db_field} >= #{value.first.to_f}"
                     end
                   end
                 when "<="
                   if [:date, :date_past].include?(type_for(field))
                     sql = date_clause(db_table, db_field, nil, (Date.parse(value.first) rescue nil))
                   else
                     if is_custom_filter
                       sql = "(#{db_table}.#{db_field} <> '' AND CAST(#{db_table}.#{db_field} AS decimal(60,3)) <= #{value.first.to_f})"
                     else
                       sql = "#{db_table}.#{db_field} <= #{value.first.to_f}"
                     end
                   end
                 when "><"
                   if [:date, :date_past].include?(type_for(field))
                     sql = date_clause(db_table, db_field, (Date.parse(value[0]) rescue nil), (Date.parse(value[1]) rescue nil))
                   else
                     if is_custom_filter
                       sql = "(#{db_table}.#{db_field} <> '' AND CAST(#{db_table}.#{db_field} AS decimal(60,3)) BETWEEN #{value[0].to_f} AND #{value[1].to_f})"
                     else
                       sql = "#{db_table}.#{db_field} BETWEEN #{value[0].to_f} AND #{value[1].to_f}"
                     end
                   end
                 when "o"
                   sql = "#{Issue.table_name}.status_id IN (SELECT id FROM #{IssueStatus.table_name} WHERE is_closed=#{connection.quoted_false})" if field == "status_id"
                 when "c"
                   sql = "#{Issue.table_name}.status_id IN (SELECT id FROM #{IssueStatus.table_name} WHERE is_closed=#{connection.quoted_true})" if field == "status_id"
                 when "><t-"
                   # between today - n days and today
                   sql = relative_date_clause(db_table, db_field, - value.first.to_i, 0)
                 when ">t-"
                   # >= today - n days
                   sql = relative_date_clause(db_table, db_field, - value.first.to_i, nil)
                 when "<t-"
                   # <= today - n days
                   sql = relative_date_clause(db_table, db_field, nil, - value.first.to_i)
                 when "t-"
                   # = n days in past
                   sql = relative_date_clause(db_table, db_field, - value.first.to_i, - value.first.to_i)
                 when "><t+"
                   # between today and today + n days
                   sql = relative_date_clause(db_table, db_field, 0, value.first.to_i)
                 when ">t+"
                   # >= today + n days
                   sql = relative_date_clause(db_table, db_field, value.first.to_i, nil)
                 when "<t+"
                   # <= today + n days
                   sql = relative_date_clause(db_table, db_field, nil, value.first.to_i)
                 when "t+"
                   # = today + n days
                   sql = relative_date_clause(db_table, db_field, value.first.to_i, value.first.to_i)
                 when "t"
                   # = today
                   sql = relative_date_clause(db_table, db_field, 0, 0)
                 when "w"
                   # = this week
                   first_day_of_week = l(:general_first_day_of_week).to_i
                   day_of_week = Date.today.cwday
                   days_ago = (day_of_week >= first_day_of_week ? day_of_week - first_day_of_week : day_of_week + 7 - first_day_of_week)
                   sql = relative_date_clause(db_table, db_field, - days_ago, - days_ago + 6)
                 when "~"
                   sql = "LOWER(#{db_table}.#{db_field}) LIKE '%#{connection.quote_string(value.first.to_s.downcase)}%'"
                 when "!~"
                   sql = "LOWER(#{db_table}.#{db_field}) NOT LIKE '%#{connection.quote_string(value.first.to_s.downcase)}%'"
                 else
                   raise "Unknown query operator #{operator}"
                 end
                 return sql
               end
               def add_custom_fields_filters(custom_fields, assoc=nil)
                 return unless custom_fields.present?
                 @available_filters ||= {}
                 custom_fields.select(&:is_filter?).each do |field|
                   case field.field_format
                   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 }
                   when "int"
                     options = { :type => :integer, :order => 20 }
                   when "float"
                     options = { :type => :float, :order => 20 }
                   when "user", "version"
                     next unless project
                     values = field.possible_values_options(project)
                     if User.current.logged? && field.field_format == 'user'
                       values.unshift ["<< #{l(:label_me)} >>", "me"]
                     end
                     options = { :type => :list_optional, :values => values, :order => 20}
                   else
                     options = { :type => :string, :order => 20 }
                   end
                   filter_id = "cf_#{field.id}"
                   filter_name = field.name
                   if assoc.present?
                     filter_id = "#{assoc}.#{filter_id}"
                     filter_name = l("label_attribute_of_#{assoc}", :name => filter_name)
                   end
                   @available_filters[filter_id] = options.merge({
                            :name => filter_name,
                            :format => field.field_format,
                            :field => field
                          })
                 end
               end
               def add_associations_custom_fields_filters(*associations)
                 fields_by_class = CustomField.where(:is_filter => true).group_by(&:class)
                 associations.each do |assoc|
                   association_klass = Issue.reflect_on_association(assoc).klass
                   fields_by_class.each do |field_class, fields|
                     if field_class.customized_class <= association_klass
                       add_custom_fields_filters(fields, assoc)
                     end
                   end
                 end
               end
               # Returns a SQL clause for a date or datetime field.
               def date_clause(table, field, from, to)
                 s = []
                 if from
                   from_yesterday = from - 1
                   from_yesterday_time = Time.local(from_yesterday.year, from_yesterday.month, from_yesterday.day)
                   if self.class.default_timezone == :utc
                     from_yesterday_time = from_yesterday_time.utc
                   end
                   s << ("#{table}.#{field} > '%s'" % [connection.quoted_date(from_yesterday_time.end_of_day)])
                 end
                 if to
                   to_time = Time.local(to.year, to.month, to.day)
                   if self.class.default_timezone == :utc
                     to_time = to_time.utc
                   end
                   s << ("#{table}.#{field} <= '%s'" % [connection.quoted_date(to_time.end_of_day)])
                 end
                 s.join(' AND ')
               end
               # Returns a SQL clause for a date or datetime field using relative dates.
               def relative_date_clause(table, field, days_from, days_to)
                 date_clause(table, field, (days_from ? Date.today + days_from : nil), (days_to ? Date.today + days_to : nil))
               end
               # Additional joins required for the given sort options
               def joins_for_order_statement(order_options)
                 joins = []
                 if order_options
                   if order_options.include?('authors')
                     joins << "LEFT OUTER JOIN #{User.table_name} authors ON authors.id = #{Issue.table_name}.author_id"
                   end
                   order_options.scan(/cf_\d+/).uniq.each do |name|
                     column = available_columns.detect {|c| c.name.to_s == name}
                     join = column && column.custom_field.join_for_order_statement
                     if join
                       joins << join
                     end
                   end
                 end
                 joins.any? ? joins.join(' ') : nil
               end
             end

app/views/settings/_issues.html.erb +1 -1

             <%= form_tag({:action => 'edit', :tab => 'issues'}, :onsubmit => 'selectAllOptions("selected_columns");') do %>
             <div class="box tabular settings">
             <p><%= setting_check_box :cross_project_issue_relations %></p>
             <p><%= setting_select :cross_project_subtasks, cross_project_subtasks_options %></p>
             <p><%= setting_check_box :issue_group_assignment %></p>
             <p><%= setting_check_box :default_issue_start_date_to_creation_date %></p>
             <p><%= setting_check_box :display_subprojects_issues %></p>
             <p><%= setting_select :issue_done_ratio, Issue::DONE_RATIO_OPTIONS.collect {|i| [l("setting_issue_done_ratio_#{i}"), i]} %></p>
             <p><%= setting_multiselect :non_working_week_days, (1..7).map {|d| [day_name(d), d.to_s]}, :inline => true %></p>
             <p><%= setting_text_field :issues_export_limit, :size => 6 %></p>
             <p><%= setting_text_field :gantt_items_limit, :size => 6 %></p>
             </div>
             <fieldset class="box">
             	<legend><%= l(:setting_issue_list_default_columns) %></legend>
               <%= render :partial => 'queries/columns',
                          :locals => {
-                           :query => Query.new(:column_names => Setting.issue_list_default_columns),
+                           :query => IssueQuery.new(:column_names => Setting.issue_list_default_columns),
                            :tag_name => 'settings[issue_list_default_columns][]'
                          } %>
             </fieldset>
             <%= submit_tag l(:button_save) %>
             <% end %>

test/fixtures/queries.yml +9 0

             ---
             queries_001:
               id: 1
+              type: IssueQuery
               project_id: 1
               is_public: true
               name: Multiple custom fields query
               filters: |
                 ---
                 cf_1:
                   :values:
                   - MySQL
                   :operator: "="
                 status_id:
                   :values:
                   - "1"
                   :operator: o
                 cf_2:
                   :values:
                   - "125"
                   :operator: "="
               user_id: 1
               column_names:
             queries_002:
               id: 2
+              type: IssueQuery
               project_id: 1
               is_public: false
               name: Private query for cookbook
               filters: |
                 ---
                 tracker_id:
                   :values:
                   - "3"
                   :operator: "="
                 status_id:
                   :values:
                   - "1"
                   :operator: o
               user_id: 3
               column_names:
             queries_003:
               id: 3
+              type: IssueQuery
               project_id:
               is_public: false
               name: Private query for all projects
               filters: |
                 ---
                 tracker_id:
                   :values:
                   - "3"
                   :operator: "="
               user_id: 3
               column_names:
             queries_004:
               id: 4
+              type: IssueQuery
               project_id:
               is_public: true
               name: Public query for all projects
               filters: |
                 ---
                 tracker_id:
                   :values:
                   - "3"
                   :operator: "="
               user_id: 2
               column_names:
             queries_005:
               id: 5
+              type: IssueQuery
               project_id:
               is_public: true
               name: Open issues by priority and tracker
               filters: |
                 ---
                 status_id:
                   :values:
                   - "1"
                   :operator: o
               user_id: 1
               column_names:
               sort_criteria: |
                 ---
                 - - priority
                   - desc
                 - - tracker
                   - asc
             queries_006:
               id: 6
+              type: IssueQuery
               project_id:
               is_public: true
               name: Open issues grouped by tracker
               filters: |
                 ---
                 status_id:
                   :values:
                   - "1"
                   :operator: o
               user_id: 1
               column_names:
               group_by: tracker
               sort_criteria: |
                 ---
                 - - priority
                   - desc
             queries_007:
               id: 7
+              type: IssueQuery
               project_id: 2
               is_public: true
               name: Public query for project 2
               filters: |
                 ---
                 tracker_id:
                   :values:
                   - "3"
                   :operator: "="
               user_id: 2
               column_names:
             queries_008:
               id: 8
+              type: IssueQuery
               project_id: 2
               is_public: false
               name: Private query for project 2
               filters: |
                 ---
                 tracker_id:
                   :values:
                   - "3"
                   :operator: "="
               user_id: 2
               column_names:
             queries_009:
               id: 9
+              type: IssueQuery
               project_id:
               is_public: true
               name: Open issues grouped by list custom field
               filters: |
                 ---
                 status_id:
                   :values:
                   - "1"
                   :operator: o
               user_id: 1
               column_names:
               group_by: cf_1
               sort_criteria: |
                 ---
                 - - priority
                   - desc

test/functional/calendars_controller_test.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  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.expand_path('../../test_helper', __FILE__)
             class CalendarsControllerTest < ActionController::TestCase
               fixtures :projects,
                        :trackers,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules
               def test_calendar
                 get :show, :project_id => 1
                 assert_response :success
                 assert_template 'calendar'
                 assert_not_nil assigns(:calendar)
               end
               def test_cross_project_calendar
                 get :show
                 assert_response :success
                 assert_template 'calendar'
                 assert_not_nil assigns(:calendar)
               end
               context "GET :show" do
                 should "run custom queries" do
-                  @query = Query.create!(:name => 'Calendar', :is_public => true)
+                  @query = IssueQuery.create!(:name => 'Calendar', :is_public => true)
                   get :show, :query_id => @query.id
                   assert_response :success
                 end
               end
               def test_week_number_calculation
                 Setting.start_of_week = 7
                 get :show, :month => '1', :year => '2010'
                 assert_response :success
                 assert_tag :tag => 'tr',
                   :descendant => {:tag => 'td',
                                   :attributes => {:class => 'week-number'}, :content => '53'},
                   :descendant => {:tag => 'td',
                                   :attributes => {:class => 'odd'}, :content => '27'},
                   :descendant => {:tag => 'td',
                                   :attributes => {:class => 'even'}, :content => '2'}
                 assert_tag :tag => 'tr',
                   :descendant => {:tag => 'td',
                                   :attributes => {:class => 'week-number'}, :content => '1'},
                   :descendant => {:tag => 'td',
                                   :attributes => {:class => 'odd'}, :content => '3'},
                   :descendant => {:tag => 'td',
                                   :attributes => {:class => 'even'}, :content => '9'}
                 Setting.start_of_week = 1
                 get :show, :month => '1', :year => '2010'
                 assert_response :success
                 assert_tag :tag => 'tr',
                   :descendant => {:tag => 'td',
                                   :attributes => {:class => 'week-number'}, :content => '53'},
                   :descendant => {:tag => 'td',
                                   :attributes => {:class => 'even'}, :content => '28'},
                   :descendant => {:tag => 'td',
                                   :attributes => {:class => 'even'}, :content => '3'}
                 assert_tag :tag => 'tr',
                   :descendant => {:tag => 'td',
                                   :attributes => {:class => 'week-number'}, :content => '1'},
                   :descendant => {:tag => 'td',
                                   :attributes => {:class => 'even'}, :content => '4'},
                   :descendant => {:tag => 'td',
                                   :attributes => {:class => 'even'}, :content => '10'}
               end
             end

test/functional/issues_controller_test.rb 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/functional/issues_controller_transaction_test.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  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.expand_path('../../test_helper', __FILE__)
             require 'issues_controller'
             class IssuesControllerTransactionTest < ActionController::TestCase
               tests IssuesController
               fixtures :projects,
                        :users,
                        :roles,
                        :members,
                        :member_roles,
                        :issues,
                        :issue_statuses,
                        :versions,
                        :trackers,
                        :projects_trackers,
                        :issue_categories,
                        :enabled_modules,
                        :enumerations,
                        :attachments,
                        :workflows,
                        :custom_fields,
                        :custom_values,
                        :custom_fields_projects,
                        :custom_fields_trackers,
                        :time_entries,
                        :journals,
                        :journal_details,
                        :queries
               self.use_transactional_fixtures = false
               def setup
                 User.current = nil
               end
               def test_update_stale_issue_should_not_update_the_issue
                 issue = Issue.find(2)
                 @request.session[:user_id] = 2
                 assert_no_difference 'Journal.count' do
                   assert_no_difference 'TimeEntry.count' do
                     put :update,
                           :id => issue.id,
                           :issue => {
                             :fixed_version_id => 4,
                             :notes => 'My notes',
                             :lock_version => (issue.lock_version - 1)
                           },
                           :time_entry => { :hours => '2.5', :comments => '', :activity_id => TimeEntryActivity.first.id }
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'div.conflict'
                 assert_select 'input[name=?][value=?]', 'conflict_resolution', 'overwrite'
                 assert_select 'input[name=?][value=?]', 'conflict_resolution', 'add_notes'
                 assert_select 'label' do
                   assert_select 'input[name=?][value=?]', 'conflict_resolution', 'cancel'
                   assert_select 'a[href=/issues/2]'
                 end
               end
               def test_update_stale_issue_should_save_attachments
                 set_tmp_attachments_directory
                 issue = Issue.find(2)
                 @request.session[:user_id] = 2
                 assert_no_difference 'Journal.count' do
                   assert_no_difference 'TimeEntry.count' do
                     assert_difference 'Attachment.count' do
                       put :update,
                             :id => issue.id,
                             :issue => {
                               :fixed_version_id => 4,
                               :notes => 'My notes',
                               :lock_version => (issue.lock_version - 1)
                             },
                             :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}},
                             :time_entry => { :hours => '2.5', :comments => '', :activity_id => TimeEntryActivity.first.id }
                     end
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 attachment = Attachment.first(:order => 'id DESC')
                 assert_tag 'input', :attributes => {:name => 'attachments[p0][token]', :value => attachment.token}
                 assert_tag 'span', :content => /testfile.txt/
               end
               def test_update_stale_issue_without_notes_should_not_show_add_notes_option
                 issue = Issue.find(2)
                 @request.session[:user_id] = 2
                 put :update, :id => issue.id,
                       :issue => {
                         :fixed_version_id => 4,
                         :notes => '',
                         :lock_version => (issue.lock_version - 1)
                       }
                 assert_tag 'div', :attributes => {:class => 'conflict'}
                 assert_tag 'input', :attributes => {:name => 'conflict_resolution', :value => 'overwrite'}
                 assert_no_tag 'input', :attributes => {:name => 'conflict_resolution', :value => 'add_notes'}
                 assert_tag 'input', :attributes => {:name => 'conflict_resolution', :value => 'cancel'}
               end
               def test_update_stale_issue_should_show_conflicting_journals
                 @request.session[:user_id] = 2
                 put :update, :id => 1,
                       :issue => {
                         :fixed_version_id => 4,
                         :notes => '',
                         :lock_version => 2
                       },
                       :last_journal_id => 1
                 assert_not_nil assigns(:conflict_journals)
                 assert_equal 1, assigns(:conflict_journals).size
                 assert_equal 2, assigns(:conflict_journals).first.id
                 assert_tag 'div', :attributes => {:class => 'conflict'},
                   :descendant => {:content => /Some notes with Redmine links/}
               end
               def test_update_stale_issue_without_previous_journal_should_show_all_journals
                 @request.session[:user_id] = 2
                 put :update, :id => 1,
                       :issue => {
                         :fixed_version_id => 4,
                         :notes => '',
                         :lock_version => 2
                       },
                       :last_journal_id => ''
                 assert_not_nil assigns(:conflict_journals)
                 assert_equal 2, assigns(:conflict_journals).size
                 assert_tag 'div', :attributes => {:class => 'conflict'},
                   :descendant => {:content => /Some notes with Redmine links/}
                 assert_tag 'div', :attributes => {:class => 'conflict'},
                   :descendant => {:content => /Journal notes/}
               end
               def test_update_stale_issue_should_show_private_journals_with_permission_only
                 journal = Journal.create!(:journalized => Issue.find(1), :notes => 'Privates notes', :private_notes => true, :user_id => 1)
                 @request.session[:user_id] = 2
                 put :update, :id => 1, :issue => {:fixed_version_id => 4, :lock_version => 2}, :last_journal_id => ''
                 assert_include journal, assigns(:conflict_journals)
                 Role.find(1).remove_permission! :view_private_notes
                 put :update, :id => 1, :issue => {:fixed_version_id => 4, :lock_version => 2}, :last_journal_id => ''
                 assert_not_include journal, assigns(:conflict_journals)
               end
               def test_update_stale_issue_with_overwrite_conflict_resolution_should_update
                 @request.session[:user_id] = 2
                 assert_difference 'Journal.count' do
                   put :update, :id => 1,
                         :issue => {
                           :fixed_version_id => 4,
                           :notes => 'overwrite_conflict_resolution',
                           :lock_version => 2
                         },
                         :conflict_resolution => 'overwrite'
                 end
                 assert_response 302
                 issue = Issue.find(1)
                 assert_equal 4, issue.fixed_version_id
                 journal = Journal.first(:order => 'id DESC')
                 assert_equal 'overwrite_conflict_resolution', journal.notes
                 assert journal.details.any?
               end
               def test_update_stale_issue_with_add_notes_conflict_resolution_should_update
                 @request.session[:user_id] = 2
                 assert_difference 'Journal.count' do
                   put :update, :id => 1,
                         :issue => {
                           :fixed_version_id => 4,
                           :notes => 'add_notes_conflict_resolution',
                           :lock_version => 2
                         },
                         :conflict_resolution => 'add_notes'
                 end
                 assert_response 302
                 issue = Issue.find(1)
                 assert_nil issue.fixed_version_id
                 journal = Journal.first(:order => 'id DESC')
                 assert_equal 'add_notes_conflict_resolution', journal.notes
                 assert journal.details.empty?
               end
               def test_update_stale_issue_with_cancel_conflict_resolution_should_redirect_without_updating
                 @request.session[:user_id] = 2
                 assert_no_difference 'Journal.count' do
                   put :update, :id => 1,
                         :issue => {
                           :fixed_version_id => 4,
                           :notes => 'add_notes_conflict_resolution',
                           :lock_version => 2
                         },
                         :conflict_resolution => 'cancel'
                 end
                 assert_redirected_to '/issues/1'
                 issue = Issue.find(1)
                 assert_nil issue.fixed_version_id
               end
               def test_put_update_with_spent_time_and_failure_should_not_add_spent_time
                 @request.session[:user_id] = 2
                 assert_no_difference('TimeEntry.count') do
                   put :update,
                        :id => 1,
                        :issue => { :subject => '' },
                        :time_entry => { :hours => '2.5', :comments => 'should not be added', :activity_id => TimeEntryActivity.first.id }
                   assert_response :success
                 end
                 assert_select 'input[name=?][value=?]', 'time_entry[hours]', '2.5'
                 assert_select 'input[name=?][value=?]', 'time_entry[comments]', 'should not be added'
                 assert_select 'select[name=?]', 'time_entry[activity_id]' do
                   assert_select 'option[value=?][selected=selected]', TimeEntryActivity.first.id
                 end
               end
               def test_index_should_rescue_invalid_sql_query
-                Query.any_instance.stubs(:statement).returns("INVALID STATEMENT")
+                IssueQuery.any_instance.stubs(:statement).returns("INVALID STATEMENT")
                 get :index
                 assert_response 500
                 assert_tag 'p', :content => /An error occurred/
                 assert_nil session[:query]
                 assert_nil session[:issues_index_sort]
               end
             end

test/unit/helpers/queries_helper_test.rb +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2012  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.expand_path('../../../test_helper', __FILE__)
             class QueriesHelperTest < ActionView::TestCase
               include QueriesHelper
               include Redmine::I18n
               fixtures :projects, :enabled_modules, :users, :members,
                        :member_roles, :roles, :trackers, :issue_statuses,
                        :issue_categories, :enumerations, :issues,
                        :watchers, :custom_fields, :custom_values, :versions,
                        :queries,
                        :projects_trackers,
                        :custom_fields_trackers
               def test_order
                 User.current = User.find_by_login('admin')
-                query = Query.new(:project => nil, :name => '_')
+                query = IssueQuery.new(:project => nil, :name => '_')
                 assert_equal 30, query.available_filters.size
                 fo = filters_options(query)
                 assert_equal 31, fo.size
                 assert_equal [], fo[0]
                 assert_equal "status_id", fo[1][1]
                 assert_equal "project_id", fo[2][1]
                 assert_equal "tracker_id", fo[3][1]
                 assert_equal "priority_id", fo[4][1]
                 assert_equal "watcher_id", fo[17][1]
                 assert_equal "is_private", fo[18][1]
               end
               def test_order_custom_fields
                 set_language_if_valid 'en'
                 field = UserCustomField.new(
                           :name => 'order test', :field_format => 'string',
                           :is_for_all => true, :is_filter => true
                         )
                 assert field.save
                 User.current = User.find_by_login('admin')
-                query = Query.new(:project => nil, :name => '_')
+                query = IssueQuery.new(:project => nil, :name => '_')
                 assert_equal 32, query.available_filters.size
                 fo = filters_options(query)
                 assert_equal 33, fo.size
                 assert_equal "Searchable field", fo[19][0]
                 assert_equal "Database", fo[20][0]
                 assert_equal "Project's Development status", fo[21][0]
                 assert_equal "Assignee's order test", fo[22][0]
                 assert_equal "Author's order test", fo[23][0]
               end
             end

test/unit/lib/redmine/helpers/gantt_test.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  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.expand_path('../../../../../test_helper', __FILE__)
             class Redmine::Helpers::GanttHelperTest < ActionView::TestCase
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :journals, :journal_details,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules,
                        :workflows,
                        :versions,
                        :groups_users
               include ApplicationHelper
               include ProjectsHelper
               include IssuesHelper
               include ERB::Util
               include Rails.application.routes.url_helpers
               def setup
                 setup_with_controller
                 User.current = User.find(1)
               end
               def today
                 @today ||= Date.today
               end
               # Creates a Gantt chart for a 4 week span
               def create_gantt(project=Project.generate!, options={})
                 @project = project
                 @gantt = Redmine::Helpers::Gantt.new(options)
                 @gantt.project = @project
-                @gantt.query = Query.create!(:project => @project, :name => 'Gantt')
+                @gantt.query = IssueQuery.create!(:project => @project, :name => 'Gantt')
                 @gantt.view = self
                 @gantt.instance_variable_set('@date_from', options[:date_from] || (today - 14))
                 @gantt.instance_variable_set('@date_to', options[:date_to] || (today + 14))
               end
               context "#number_of_rows" do
                 context "with one project" do
                   should "return the number of rows just for that project"
                 end
                 context "with no project" do
                   should "return the total number of rows for all the projects, resursively"
                 end
                 should "not exceed max_rows option" do
                   p = Project.generate!
 .times do
                     Issue.generate!(:project => p)
                   end
                   create_gantt(p)
                   @gantt.render
                   assert_equal 6, @gantt.number_of_rows
                   assert !@gantt.truncated
                   create_gantt(p, :max_rows => 3)
                   @gantt.render
                   assert_equal 3, @gantt.number_of_rows
                   assert @gantt.truncated
                 end
               end
               context "#number_of_rows_on_project" do
                 setup do
                   create_gantt
                 end
                 should "count 0 for an empty the project" do
                   assert_equal 0, @gantt.number_of_rows_on_project(@project)
                 end
                 should "count the number of issues without a version" do
                   @project.issues << Issue.generate!(:project => @project, :fixed_version => nil)
                   assert_equal 2, @gantt.number_of_rows_on_project(@project)
                 end
                 should "count the number of issues on versions, including cross-project" do
                   version = Version.generate!
                   @project.versions << version
                   @project.issues << Issue.generate!(:project => @project, :fixed_version => version)
                   assert_equal 3, @gantt.number_of_rows_on_project(@project)
                 end
               end
               # TODO: more of an integration test
               context "#subjects" do
                 setup do
                   create_gantt
                   @project.enabled_module_names = [:issue_tracking]
                   @tracker = Tracker.generate!
                   @project.trackers << @tracker
                   @version = Version.generate!(:effective_date => (today + 7), :sharing => 'none')
                   @project.versions << @version
                   @issue = Issue.generate!(:fixed_version => @version,
                                            :subject => "gantt#line_for_project",
                                            :tracker => @tracker,
                                            :project => @project,
                                            :done_ratio => 30,
                                            :start_date => (today - 1),
                                            :due_date => (today + 7))
                   @project.issues << @issue
                 end
                 context "project" do
                   should "be rendered" do
                     @output_buffer = @gantt.subjects
                     assert_select "div.project-name a", /#{@project.name}/
                   end
                   should "have an indent of 4" do
                     @output_buffer = @gantt.subjects
                     assert_select "div.project-name[style*=left:4px]"
                   end
                 end
                 context "version" do
                   should "be rendered" do
                     @output_buffer = @gantt.subjects
                     assert_select "div.version-name a", /#{@version.name}/
                   end
                   should "be indented 24 (one level)" do
                     @output_buffer = @gantt.subjects
                     assert_select "div.version-name[style*=left:24px]"
                   end
                   context "without assigned issues" do
                     setup do
                       @version = Version.generate!(:effective_date => (today + 14),
                                                    :sharing => 'none',
                                                    :name => 'empty_version')
                       @project.versions << @version
                     end
                     should "not be rendered" do
                       @output_buffer = @gantt.subjects
                       assert_select "div.version-name a", :text => /#{@version.name}/, :count => 0
                     end
                   end
                 end
                 context "issue" do
                   should "be rendered" do
                     @output_buffer = @gantt.subjects
                     assert_select "div.issue-subject", /#{@issue.subject}/
                   end
                   should "be indented 44 (two levels)" do
                     @output_buffer = @gantt.subjects
                     assert_select "div.issue-subject[style*=left:44px]"
                   end
                   context "assigned to a shared version of another project" do
                     setup do
                       p = Project.generate!
                       p.enabled_module_names = [:issue_tracking]
                       @shared_version = Version.generate!(:sharing => 'system')
                       p.versions << @shared_version
                       # Reassign the issue to a shared version of another project
                       @issue = Issue.generate!(:fixed_version => @shared_version,
                                                :subject => "gantt#assigned_to_shared_version",
                                                :tracker => @tracker,
                                                :project => @project,
                                                :done_ratio => 30,
                                                :start_date => (today - 1),
                                                :due_date => (today + 7))
                       @project.issues << @issue
                     end
                     should "be rendered" do
                       @output_buffer = @gantt.subjects
                       assert_select "div.issue-subject", /#{@issue.subject}/
                     end
                   end
                   context "with subtasks" do
                     setup do
                       attrs = {:project => @project, :tracker => @tracker, :fixed_version => @version}
                       @child1 = Issue.generate!(
                                    attrs.merge(:subject => 'child1',
                                                :parent_issue_id => @issue.id,
                                                :start_date => (today - 1),
                                                :due_date => (today + 2))
                                   )
                       @child2 = Issue.generate!(
                                    attrs.merge(:subject => 'child2',
                                                :parent_issue_id => @issue.id,
                                                :start_date => today,
                                                :due_date => (today + 7))
                                    )
                       @grandchild = Issue.generate!(
                                       attrs.merge(:subject => 'grandchild',
                                                   :parent_issue_id => @child1.id,
                                                   :start_date => (today - 1),
                                                   :due_date => (today + 2))
                                       )
                     end
                     should "indent subtasks" do
                       @output_buffer = @gantt.subjects
                       # parent task 44px
                       assert_select "div.issue-subject[style*=left:44px]", /#{@issue.subject}/
                       # children 64px
                       assert_select "div.issue-subject[style*=left:64px]", /child1/
                       assert_select "div.issue-subject[style*=left:64px]", /child2/
                       # grandchild 84px
                       assert_select "div.issue-subject[style*=left:84px]", /grandchild/, @output_buffer
                     end
                   end
                 end
               end
               context "#lines" do
                 setup do
                   create_gantt
                   @project.enabled_module_names = [:issue_tracking]
                   @tracker = Tracker.generate!
                   @project.trackers << @tracker
                   @version = Version.generate!(:effective_date => (today + 7))
                   @project.versions << @version
                   @issue = Issue.generate!(:fixed_version => @version,
                                            :subject => "gantt#line_for_project",
                                            :tracker => @tracker,
                                            :project => @project,
                                            :done_ratio => 30,
                                            :start_date => (today - 1),
                                            :due_date => (today + 7))
                   @project.issues << @issue
                   @output_buffer = @gantt.lines
                 end
                 context "project" do
                   should "be rendered" do
                     assert_select "div.project.task_todo"
                     assert_select "div.project.starting"
                     assert_select "div.project.ending"
                     assert_select "div.label.project", /#{@project.name}/
                   end
                 end
                 context "version" do
                   should "be rendered" do
                     assert_select "div.version.task_todo"
                     assert_select "div.version.starting"
                     assert_select "div.version.ending"
                     assert_select "div.label.version", /#{@version.name}/
                   end
                 end
                 context "issue" do
                   should "be rendered" do
                     assert_select "div.task_todo"
                     assert_select "div.task.label", /#{@issue.done_ratio}/
                     assert_select "div.tooltip", /#{@issue.subject}/
                   end
                 end
               end
               context "#render_project" do
                 should "be tested"
               end
               context "#render_issues" do
                 should "be tested"
               end
               context "#render_version" do
                 should "be tested"
               end
               context "#subject_for_project" do
                 setup do
                   create_gantt
                 end
                 context ":html format" do
                   should "add an absolute positioned div" do
                     @output_buffer = @gantt.subject_for_project(@project, {:format => :html})
                     assert_select "div[style*=absolute]"
                   end
                   should "use the indent option to move the div to the right" do
                     @output_buffer = @gantt.subject_for_project(@project, {:format => :html, :indent => 40})
                     assert_select "div[style*=left:40]"
                   end
                   should "include the project name" do
                     @output_buffer = @gantt.subject_for_project(@project, {:format => :html})
                     assert_select 'div', :text => /#{@project.name}/
                   end
                   should "include a link to the project" do
                     @output_buffer = @gantt.subject_for_project(@project, {:format => :html})
                     assert_select 'a[href=?]', "/projects/#{@project.identifier}", :text => /#{@project.name}/
                   end
                   should "style overdue projects" do
                     @project.enabled_module_names = [:issue_tracking]
                     @project.versions << Version.generate!(:effective_date => (today - 1))
                     assert @project.reload.overdue?, "Need an overdue project for this test"
                     @output_buffer = @gantt.subject_for_project(@project, {:format => :html})
                     assert_select 'div span.project-overdue'
                   end
                 end
                 should "test the PNG format"
                 should "test the PDF format"
               end
               context "#line_for_project" do
                 setup do
                   create_gantt
                   @project.enabled_module_names = [:issue_tracking]
                   @tracker = Tracker.generate!
                   @project.trackers << @tracker
                   @version = Version.generate!(:effective_date => (today - 1))
                   @project.versions << @version
                   @project.issues << Issue.generate!(:fixed_version => @version,
                                                      :subject => "gantt#line_for_project",
                                                      :tracker => @tracker,
                                                      :project => @project,
                                                      :done_ratio => 30,
                                                      :start_date => (today - 7),
                                                      :due_date => (today + 7))
                 end
                 context ":html format" do
                   context "todo line" do
                     should "start from the starting point on the left" do
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.task_todo[style*=left:28px]", true, @output_buffer
                     end
                     should "be the total width of the project" do
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.task_todo[style*=width:58px]", true, @output_buffer
                     end
                   end
                   context "late line" do
                     should_eventually "start from the starting point on the left" do
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.task_late[style*=left:28px]", true, @output_buffer
                     end
                     should_eventually "be the total delayed width of the project" do
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.task_late[style*=width:30px]", true, @output_buffer
                     end
                   end
                   context "done line" do
                     should_eventually "start from the starting point on the left" do
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.task_done[style*=left:28px]", true, @output_buffer
                     end
                     should_eventually "Be the total done width of the project"  do
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.task_done[style*=width:18px]", true, @output_buffer
                     end
                   end
                   context "starting marker" do
                     should "not appear if the starting point is off the gantt chart" do
                       # Shift the date range of the chart
                       @gantt.instance_variable_set('@date_from', today)
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.starting", false, @output_buffer
                     end
                     should "appear at the starting point" do
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.starting[style*=left:28px]", true, @output_buffer
                     end
                   end
                   context "ending marker" do
                     should "not appear if the starting point is off the gantt chart" do
                       # Shift the date range of the chart
                       @gantt.instance_variable_set('@date_to', (today - 14))
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.ending", false, @output_buffer
                     end
                     should "appear at the end of the date range" do
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.ending[style*=left:88px]", true, @output_buffer
                     end
                   end
                   context "status content" do
                     should "appear at the far left, even if it's far in the past" do
                       @gantt.instance_variable_set('@date_to', (today - 14))
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.label", /#{@project.name}/
                     end
                     should "show the project name" do
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.label", /#{@project.name}/
                     end
                     should_eventually "show the percent complete" do
                       @output_buffer = @gantt.line_for_project(@project, {:format => :html, :zoom => 4})
                       assert_select "div.project.label", /0%/
                     end
                   end
                 end
                 should "test the PNG format"
                 should "test the PDF format"
               end
               context "#subject_for_version" do
                 setup do
                   create_gantt
                   @project.enabled_module_names = [:issue_tracking]
                   @tracker = Tracker.generate!
                   @project.trackers << @tracker
                   @version = Version.generate!(:effective_date => (today - 1))
                   @project.versions << @version
                   @project.issues << Issue.generate!(:fixed_version => @version,
                                                      :subject => "gantt#subject_for_version",
                                                      :tracker => @tracker,
                                                      :project => @project,
                                                      :start_date => today)
                 end
                 context ":html format" do
                   should "add an absolute positioned div" do
                     @output_buffer = @gantt.subject_for_version(@version, {:format => :html})
                     assert_select "div[style*=absolute]"
                   end
                   should "use the indent option to move the div to the right" do
                     @output_buffer = @gantt.subject_for_version(@version, {:format => :html, :indent => 40})
                     assert_select "div[style*=left:40]"
                   end
                   should "include the version name" do
                     @output_buffer = @gantt.subject_for_version(@version, {:format => :html})
                     assert_select 'div', :text => /#{@version.name}/
                   end
                   should "include a link to the version" do
                     @output_buffer = @gantt.subject_for_version(@version, {:format => :html})
                     assert_select 'a[href=?]', Regexp.escape("/versions/#{@version.to_param}"), :text => /#{@version.name}/
                   end
                   should "style late versions" do
                     assert @version.overdue?, "Need an overdue version for this test"
                     @output_buffer = @gantt.subject_for_version(@version, {:format => :html})
                     assert_select 'div span.version-behind-schedule'
                   end
                   should "style behind schedule versions" do
                     assert @version.behind_schedule?, "Need a behind schedule version for this test"
                     @output_buffer = @gantt.subject_for_version(@version, {:format => :html})
                     assert_select 'div span.version-behind-schedule'
                   end
                 end
                 should "test the PNG format"
                 should "test the PDF format"
               end
               context "#line_for_version" do
                 setup do
                   create_gantt
                   @project.enabled_module_names = [:issue_tracking]
                   @tracker = Tracker.generate!
                   @project.trackers << @tracker
                   @version = Version.generate!(:effective_date => (today + 7))
                   @project.versions << @version
                   @project.issues << Issue.generate!(:fixed_version => @version,
                                                      :subject => "gantt#line_for_project",
                                                      :tracker => @tracker,
                                                      :project => @project,
                                                      :done_ratio => 30,
                                                      :start_date => (today - 7),
                                                      :due_date => (today + 7))
                 end
                 context ":html format" do
                   context "todo line" do
                     should "start from the starting point on the left" do
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.task_todo[style*=left:28px]", true, @output_buffer
                     end
                     should "be the total width of the version" do
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.task_todo[style*=width:58px]", true, @output_buffer
                     end
                   end
                   context "late line" do
                     should "start from the starting point on the left" do
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.task_late[style*=left:28px]", true, @output_buffer
                     end
                     should "be the total delayed width of the version" do
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.task_late[style*=width:30px]", true, @output_buffer
                     end
                   end
                   context "done line" do
                     should "start from the starting point on the left" do
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.task_done[style*=left:28px]", true, @output_buffer
                     end
                     should "be the total done width of the version"  do
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.task_done[style*=width:16px]", true, @output_buffer
                     end
                   end
                   context "starting marker" do
                     should "not appear if the starting point is off the gantt chart" do
                       # Shift the date range of the chart
                       @gantt.instance_variable_set('@date_from', today)
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.starting", false
                     end
                     should "appear at the starting point" do
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.starting[style*=left:28px]", true, @output_buffer
                     end
                   end
                   context "ending marker" do
                     should "not appear if the starting point is off the gantt chart" do
                       # Shift the date range of the chart
                       @gantt.instance_variable_set('@date_to', (today - 14))
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.ending", false
                     end
                     should "appear at the end of the date range" do
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.ending[style*=left:88px]", true, @output_buffer
                     end
                   end
                   context "status content" do
                     should "appear at the far left, even if it's far in the past" do
                       @gantt.instance_variable_set('@date_to', (today - 14))
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.label", /#{@version.name}/
                     end
                     should "show the version name" do
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.label", /#{@version.name}/
                     end
                     should "show the percent complete" do
                       @output_buffer = @gantt.line_for_version(@version, {:format => :html, :zoom => 4})
                       assert_select "div.version.label", /30%/
                     end
                   end
                 end
                 should "test the PNG format"
                 should "test the PDF format"
               end
               context "#subject_for_issue" do
                 setup do
                   create_gantt
                   @project.enabled_module_names = [:issue_tracking]
                   @tracker = Tracker.generate!
                   @project.trackers << @tracker
                   @issue = Issue.generate!(:subject => "gantt#subject_for_issue",
                                            :tracker => @tracker,
                                            :project => @project,
                                            :start_date => (today - 3),
                                            :due_date => (today - 1))
                   @project.issues << @issue
                 end
                 context ":html format" do
                   should "add an absolute positioned div" do
                     @output_buffer = @gantt.subject_for_issue(@issue, {:format => :html})
                     assert_select "div[style*=absolute]"
                   end
                   should "use the indent option to move the div to the right" do
                     @output_buffer = @gantt.subject_for_issue(@issue, {:format => :html, :indent => 40})
                     assert_select "div[style*=left:40]"
                   end
                   should "include the issue subject" do
                     @output_buffer = @gantt.subject_for_issue(@issue, {:format => :html})
                     assert_select 'div', :text => /#{@issue.subject}/
                   end
                   should "include a link to the issue" do
                     @output_buffer = @gantt.subject_for_issue(@issue, {:format => :html})
                     assert_select 'a[href=?]', Regexp.escape("/issues/#{@issue.to_param}"), :text => /#{@tracker.name} ##{@issue.id}/
                   end
                   should "style overdue issues" do
                     assert @issue.overdue?, "Need an overdue issue for this test"
                     @output_buffer = @gantt.subject_for_issue(@issue, {:format => :html})
                     assert_select 'div span.issue-overdue'
                   end
                 end
                 should "test the PNG format"
                 should "test the PDF format"
               end
               context "#line_for_issue" do
                 setup do
                   create_gantt
                   @project.enabled_module_names = [:issue_tracking]
                   @tracker = Tracker.generate!
                   @project.trackers << @tracker
                   @version = Version.generate!(:effective_date => (today + 7))
                   @project.versions << @version
                   @issue = Issue.generate!(:fixed_version => @version,
                                            :subject => "gantt#line_for_project",
                                            :tracker => @tracker,
                                            :project => @project,
                                            :done_ratio => 30,
                                            :start_date => (today - 7),
                                            :due_date => (today + 7))
                   @project.issues << @issue
                 end
                 context ":html format" do
                   context "todo line" do
                     should "start from the starting point on the left" do
                       @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                       assert_select "div.task_todo[style*=left:28px]", true, @output_buffer
                     end
                     should "be the total width of the issue" do
                       @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                       assert_select "div.task_todo[style*=width:58px]", true, @output_buffer
                     end
                   end
                   context "late line" do
                     should "start from the starting point on the left" do
                       @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                       assert_select "div.task_late[style*=left:28px]", true, @output_buffer
                     end
                     should "be the total delayed width of the issue" do
                       @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                       assert_select "div.task_late[style*=width:30px]", true, @output_buffer
                     end
                   end
                   context "done line" do
                     should "start from the starting point on the left" do
                       @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                       assert_select "div.task_done[style*=left:28px]", true, @output_buffer
                     end
                     should "be the total done width of the issue"  do
                       @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                       # 15 days * 4 px * 30% - 2 px for borders = 16 px
                       assert_select "div.task_done[style*=width:16px]", true, @output_buffer
                     end
                     should "not be the total done width if the chart starts after issue start date"  do
                       create_gantt(@project, :date_from => (today - 5))
                       @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                       assert_select "div.task_done[style*=left:0px]", true, @output_buffer
                       assert_select "div.task_done[style*=width:8px]", true, @output_buffer
                     end
                     context "for completed issue" do
                       setup do
                         @issue.done_ratio = 100
                       end
                       should "be the total width of the issue"  do
                         @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                         assert_select "div.task_done[style*=width:58px]", true, @output_buffer
                       end
                       should "be the total width of the issue with due_date=start_date"  do
                         @issue.due_date = @issue.start_date
                         @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                         assert_select "div.task_done[style*=width:2px]", true, @output_buffer
                       end
                     end
                   end
                   context "status content" do
                     should "appear at the far left, even if it's far in the past" do
                       @gantt.instance_variable_set('@date_to', (today - 14))
                       @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                       assert_select "div.task.label", true, @output_buffer
                     end
                     should "show the issue status" do
                       @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                       assert_select "div.task.label", /#{@issue.status.name}/
                     end
                     should "show the percent complete" do
                       @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                       assert_select "div.task.label", /30%/
                     end
                   end
                 end
                 should "have an issue tooltip" do
                   @output_buffer = @gantt.line_for_issue(@issue, {:format => :html, :zoom => 4})
                   assert_select "div.tooltip", /#{@issue.subject}/
                 end
                 should "test the PNG format"
                 should "test the PDF format"
               end
               context "#to_image" do
                 should "be tested"
               end
               context "#to_pdf" do
                 should "be tested"
               end
             end

test/unit/query_test.rb +121 -122

             # Redmine - project management software
             # Copyright (C) 2006-2012  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.expand_path('../../test_helper', __FILE__)
             class QueryTest < ActiveSupport::TestCase
               include Redmine::I18n
               fixtures :projects, :enabled_modules, :users, :members,
                        :member_roles, :roles, :trackers, :issue_statuses,
                        :issue_categories, :enumerations, :issues,
                        :watchers, :custom_fields, :custom_values, :versions,
                        :queries,
                        :projects_trackers,
                        :custom_fields_trackers
               def test_custom_fields_for_all_projects_should_be_available_in_global_queries
-                query = Query.new(:project => nil, :name => '_')
+                query = IssueQuery.new(:project => nil, :name => '_')
                 assert query.available_filters.has_key?('cf_1')
                 assert !query.available_filters.has_key?('cf_3')
               end
               def test_system_shared_versions_should_be_available_in_global_queries
                 Version.find(2).update_attribute :sharing, 'system'
-                query = Query.new(:project => nil, :name => '_')
+                query = IssueQuery.new(:project => nil, :name => '_')
                 assert query.available_filters.has_key?('fixed_version_id')
                 assert query.available_filters['fixed_version_id'][:values].detect {|v| v.last == '2'}
               end
               def test_project_filter_in_global_queries
-                query = Query.new(:project => nil, :name => '_')
+                query = IssueQuery.new(:project => nil, :name => '_')
                 project_filter = query.available_filters["project_id"]
                 assert_not_nil project_filter
                 project_ids = project_filter[:values].map{|p| p[1]}
                 assert project_ids.include?("1")  #public project
                 assert !project_ids.include?("2") #private project user cannot see
               end
               def find_issues_with_query(query)
                 Issue.includes([:assigned_to, :status, :tracker, :project, :priority]).where(
                      query.statement
                    ).all
               end
               def assert_find_issues_with_query_is_successful(query)
                 assert_nothing_raised do
                   find_issues_with_query(query)
                 end
               end
               def assert_query_statement_includes(query, condition)
                 assert query.statement.include?(condition), "Query statement condition not found in: #{query.statement}"
               end
               def assert_query_result(expected, query)
                 assert_nothing_raised do
                   assert_equal expected.map(&:id).sort, query.issues.map(&:id).sort
                   assert_equal expected.size, query.issue_count
                 end
               end
               def test_query_should_allow_shared_versions_for_a_project_query
                 subproject_version = Version.find(4)
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('fixed_version_id', '=', [subproject_version.id.to_s])
                 assert query.statement.include?("#{Issue.table_name}.fixed_version_id IN ('4')")
               end
               def test_query_with_multiple_custom_fields
-                query = Query.find(1)
+                query = IssueQuery.find(1)
                 assert query.valid?
                 assert query.statement.include?("#{CustomValue.table_name}.value IN ('MySQL')")
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.length
                 assert_equal Issue.find(3), issues.first
               end
               def test_operator_none
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('fixed_version_id', '!*', [''])
                 query.add_filter('cf_1', '!*', [''])
                 assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NULL")
                 assert query.statement.include?("#{CustomValue.table_name}.value IS NULL OR #{CustomValue.table_name}.value = ''")
                 find_issues_with_query(query)
               end
               def test_operator_none_for_integer
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('estimated_hours', '!*', [''])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 assert issues.all? {|i| !i.estimated_hours}
               end
               def test_operator_none_for_date
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('start_date', '!*', [''])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 assert issues.all? {|i| i.start_date.nil?}
               end
               def test_operator_none_for_string_custom_field
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('cf_2', '!*', [''])
                 assert query.has_filter?('cf_2')
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 assert issues.all? {|i| i.custom_field_value(2).blank?}
               end
               def test_operator_all
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('fixed_version_id', '*', [''])
                 query.add_filter('cf_1', '*', [''])
                 assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NOT NULL")
                 assert query.statement.include?("#{CustomValue.table_name}.value IS NOT NULL AND #{CustomValue.table_name}.value <> ''")
                 find_issues_with_query(query)
               end
               def test_operator_all_for_date
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('start_date', '*', [''])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 assert issues.all? {|i| i.start_date.present?}
               end
               def test_operator_all_for_string_custom_field
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('cf_2', '*', [''])
                 assert query.has_filter?('cf_2')
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 assert issues.all? {|i| i.custom_field_value(2).present?}
               end
               def test_numeric_filter_should_not_accept_non_numeric_values
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter('estimated_hours', '=', ['a'])
                 assert query.has_filter?('estimated_hours')
                 assert !query.valid?
               end
               def test_operator_is_on_float
                 Issue.update_all("estimated_hours = 171.2", "id=2")
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter('estimated_hours', '=', ['171.20'])
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.size
                 assert_equal 2, issues.first.id
               end
               def test_operator_is_on_integer_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_for_all => true, :is_filter => true)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '=', ['12'])
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.size
                 assert_equal 2, issues.first.id
               end
               def test_operator_is_on_integer_custom_field_should_accept_negative_value
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_for_all => true, :is_filter => true)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '-12')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '=', ['-12'])
                 assert query.valid?
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.size
                 assert_equal 2, issues.first.id
               end
               def test_operator_is_on_float_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'float', :is_filter => true, :is_for_all => true)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7.3')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12.7')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '=', ['12.7'])
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.size
                 assert_equal 2, issues.first.id
               end
               def test_operator_is_on_float_custom_field_should_accept_negative_value
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'float', :is_filter => true, :is_for_all => true)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7.3')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '-12.7')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '=', ['-12.7'])
                 assert query.valid?
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.size
                 assert_equal 2, issues.first.id
               end
               def test_operator_is_on_multi_list_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'list', :is_filter => true, :is_for_all => true,
                   :possible_values => ['value1', 'value2', 'value3'], :multiple => true)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value1')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value2')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => 'value1')
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '=', ['value1'])
                 issues = find_issues_with_query(query)
                 assert_equal [1, 3], issues.map(&:id).sort
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '=', ['value2'])
                 issues = find_issues_with_query(query)
                 assert_equal [1], issues.map(&:id).sort
               end
               def test_operator_is_not_on_multi_list_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'list', :is_filter => true, :is_for_all => true,
                   :possible_values => ['value1', 'value2', 'value3'], :multiple => true)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value1')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value2')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => 'value1')
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '!', ['value1'])
                 issues = find_issues_with_query(query)
                 assert !issues.map(&:id).include?(1)
                 assert !issues.map(&:id).include?(3)
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '!', ['value2'])
                 issues = find_issues_with_query(query)
                 assert !issues.map(&:id).include?(1)
                 assert issues.map(&:id).include?(3)
               end
               def test_operator_is_on_is_private_field
                 # is_private filter only available for those who can set issues private
                 User.current = User.find(2)
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 assert query.available_filters.key?('is_private')
                 query.add_filter("is_private", '=', ['1'])
                 issues = find_issues_with_query(query)
                 assert issues.any?
                 assert_nil issues.detect {|issue| !issue.is_private?}
               ensure
                 User.current = nil
               end
               def test_operator_is_not_on_is_private_field
                 # is_private filter only available for those who can set issues private
                 User.current = User.find(2)
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 assert query.available_filters.key?('is_private')
                 query.add_filter("is_private", '!', ['1'])
                 issues = find_issues_with_query(query)
                 assert issues.any?
                 assert_nil issues.detect {|issue| issue.is_private?}
               ensure
                 User.current = nil
               end
               def test_operator_greater_than
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('done_ratio', '>=', ['40'])
                 assert query.statement.include?("#{Issue.table_name}.done_ratio >= 40.0")
                 find_issues_with_query(query)
               end
               def test_operator_greater_than_a_float
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('estimated_hours', '>=', ['40.5'])
                 assert query.statement.include?("#{Issue.table_name}.estimated_hours >= 40.5")
                 find_issues_with_query(query)
               end
               def test_operator_greater_than_on_int_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter("cf_#{f.id}", '>=', ['8'])
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.size
                 assert_equal 2, issues.first.id
               end
               def test_operator_lesser_than
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('done_ratio', '<=', ['30'])
                 assert query.statement.include?("#{Issue.table_name}.done_ratio <= 30.0")
                 find_issues_with_query(query)
               end
               def test_operator_lesser_than_on_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true)
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter("cf_#{f.id}", '<=', ['30'])
                 assert query.statement.include?("CAST(custom_values.value AS decimal(60,3)) <= 30.0")
                 find_issues_with_query(query)
               end
               def test_operator_between
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('done_ratio', '><', ['30', '40'])
                 assert_include "#{Issue.table_name}.done_ratio BETWEEN 30.0 AND 40.0", query.statement
                 find_issues_with_query(query)
               end
               def test_operator_between_on_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true)
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter("cf_#{f.id}", '><', ['30', '40'])
                 assert_include "CAST(custom_values.value AS decimal(60,3)) BETWEEN 30.0 AND 40.0", query.statement
                 find_issues_with_query(query)
               end
               def test_date_filter_should_not_accept_non_date_values
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter('created_on', '=', ['a'])
                 assert query.has_filter?('created_on')
                 assert !query.valid?
               end
               def test_date_filter_should_not_accept_invalid_date_values
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter('created_on', '=', ['2011-01-34'])
                 assert query.has_filter?('created_on')
                 assert !query.valid?
               end
               def test_relative_date_filter_should_not_accept_non_integer_values
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter('created_on', '>t-', ['a'])
                 assert query.has_filter?('created_on')
                 assert !query.valid?
               end
               def test_operator_date_equals
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter('due_date', '=', ['2011-07-10'])
                 assert_match /issues\.due_date > '2011-07-09 23:59:59(\.9+)?' AND issues\.due_date <= '2011-07-10 23:59:59(\.9+)?/, query.statement
                 find_issues_with_query(query)
               end
               def test_operator_date_lesser_than
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter('due_date', '<=', ['2011-07-10'])
                 assert_match /issues\.due_date <= '2011-07-10 23:59:59(\.9+)?/, query.statement
                 find_issues_with_query(query)
               end
               def test_operator_date_greater_than
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter('due_date', '>=', ['2011-07-10'])
                 assert_match /issues\.due_date > '2011-07-09 23:59:59(\.9+)?'/, query.statement
                 find_issues_with_query(query)
               end
               def test_operator_date_between
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.add_filter('due_date', '><', ['2011-06-23', '2011-07-10'])
                 assert_match /issues\.due_date > '2011-06-22 23:59:59(\.9+)?' AND issues\.due_date <= '2011-07-10 23:59:59(\.9+)?/, query.statement
                 find_issues_with_query(query)
               end
               def test_operator_in_more_than
                 Issue.find(7).update_attribute(:due_date, (Date.today + 15))
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '>t+', ['15'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date >= (Date.today + 15))}
               end
               def test_operator_in_less_than
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '<t+', ['15'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date <= (Date.today + 15))}
               end
               def test_operator_in_the_next_days
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '><t+', ['15'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date >= Date.today && issue.due_date <= (Date.today + 15))}
               end
               def test_operator_less_than_ago
                 Issue.find(7).update_attribute(:due_date, (Date.today - 3))
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '>t-', ['3'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date >= (Date.today - 3))}
               end
               def test_operator_in_the_past_days
                 Issue.find(7).update_attribute(:due_date, (Date.today - 3))
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '><t-', ['3'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date >= (Date.today - 3) && issue.due_date <= Date.today)}
               end
               def test_operator_more_than_ago
                 Issue.find(7).update_attribute(:due_date, (Date.today - 10))
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '<t-', ['10'])
                 assert query.statement.include?("#{Issue.table_name}.due_date <=")
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date <= (Date.today - 10))}
               end
               def test_operator_in
                 Issue.find(7).update_attribute(:due_date, (Date.today + 2))
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 't+', ['2'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert_equal((Date.today + 2), issue.due_date)}
               end
               def test_operator_ago
                 Issue.find(7).update_attribute(:due_date, (Date.today - 3))
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 't-', ['3'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert_equal((Date.today - 3), issue.due_date)}
               end
               def test_operator_today
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 't', [''])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert_equal Date.today, issue.due_date}
               end
               def test_operator_this_week_on_date
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 'w', [''])
                 find_issues_with_query(query)
               end
               def test_operator_this_week_on_datetime
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('created_on', 'w', [''])
                 find_issues_with_query(query)
               end
               def test_operator_contains
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('subject', '~', ['uNable'])
                 assert query.statement.include?("LOWER(#{Issue.table_name}.subject) LIKE '%unable%'")
                 result = find_issues_with_query(query)
                 assert result.empty?
                 result.each {|issue| assert issue.subject.downcase.include?('unable') }
               end
               def test_range_for_this_week_with_week_starting_on_monday
                 I18n.locale = :fr
                 assert_equal '1', I18n.t(:general_first_day_of_week)
                 Date.stubs(:today).returns(Date.parse('2011-04-29'))
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 'w', [''])
                 assert query.statement.match(/issues\.due_date > '2011-04-24 23:59:59(\.9+)?' AND issues\.due_date <= '2011-05-01 23:59:59(\.9+)?/), "range not found in #{query.statement}"
                 I18n.locale = :en
               end
               def test_range_for_this_week_with_week_starting_on_sunday
                 I18n.locale = :en
                 assert_equal '7', I18n.t(:general_first_day_of_week)
                 Date.stubs(:today).returns(Date.parse('2011-04-29'))
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 'w', [''])
                 assert query.statement.match(/issues\.due_date > '2011-04-23 23:59:59(\.9+)?' AND issues\.due_date <= '2011-04-30 23:59:59(\.9+)?/), "range not found in #{query.statement}"
               end
               def test_operator_does_not_contains
-                query = Query.new(:project => Project.find(1), :name => '_')
+                query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('subject', '!~', ['uNable'])
                 assert query.statement.include?("LOWER(#{Issue.table_name}.subject) NOT LIKE '%unable%'")
                 find_issues_with_query(query)
               end
               def test_filter_assigned_to_me
                 user = User.find(2)
                 group = Group.find(10)
                 User.current = user
                 i1 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => user)
                 i2 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => group)
                 i3 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => Group.find(11))
                 group.users << user
-                query = Query.new(:name => '_', :filters => { 'assigned_to_id' => {:operator => '=', :values => ['me']}})
+                query = IssueQuery.new(:name => '_', :filters => { 'assigned_to_id' => {:operator => '=', :values => ['me']}})
                 result = query.issues
                 assert_equal Issue.visible.all(:conditions => {:assigned_to_id => ([2] + user.reload.group_ids)}).sort_by(&:id), result.sort_by(&:id)
                 assert result.include?(i1)
                 assert result.include?(i2)
                 assert !result.include?(i3)
               end
               def test_user_custom_field_filtered_on_me
                 User.current = User.find(2)
                 cf = IssueCustomField.create!(:field_format => 'user', :is_for_all => true, :is_filter => true, :name => 'User custom field', :tracker_ids => [1])
                 issue1 = Issue.create!(:project_id => 1, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '2'}, :subject => 'Test', :author_id => 1)
                 issue2 = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '3'})
-                query = Query.new(:name => '_', :project => Project.find(1))
+                query = IssueQuery.new(:name => '_', :project => Project.find(1))
                 filter = query.available_filters["cf_#{cf.id}"]
                 assert_not_nil filter
                 assert_include 'me', filter[:values].map{|v| v[1]}
                 query.filters = { "cf_#{cf.id}" => {:operator => '=', :values => ['me']}}
                 result = query.issues
                 assert_equal 1, result.size
                 assert_equal issue1, result.first
               end
               def test_filter_my_projects
                 User.current = User.find(2)
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 filter = query.available_filters['project_id']
                 assert_not_nil filter
                 assert_include 'mine', filter[:values].map{|v| v[1]}
                 query.filters = { 'project_id' => {:operator => '=', :values => ['mine']}}
                 result = query.issues
                 assert_nil result.detect {|issue| !User.current.member_of?(issue.project)}
               end
               def test_filter_watched_issues
                 User.current = User.find(1)
-                query = Query.new(:name => '_', :filters => { 'watcher_id' => {:operator => '=', :values => ['me']}})
+                query = IssueQuery.new(:name => '_', :filters => { 'watcher_id' => {:operator => '=', :values => ['me']}})
                 result = find_issues_with_query(query)
                 assert_not_nil result
                 assert !result.empty?
                 assert_equal Issue.visible.watched_by(User.current).sort_by(&:id), result.sort_by(&:id)
                 User.current = nil
               end
               def test_filter_unwatched_issues
                 User.current = User.find(1)
-                query = Query.new(:name => '_', :filters => { 'watcher_id' => {:operator => '!', :values => ['me']}})
+                query = IssueQuery.new(:name => '_', :filters => { 'watcher_id' => {:operator => '!', :values => ['me']}})
                 result = find_issues_with_query(query)
                 assert_not_nil result
                 assert !result.empty?
                 assert_equal((Issue.visible - Issue.watched_by(User.current)).sort_by(&:id).size, result.sort_by(&:id).size)
                 User.current = nil
               end
               def test_filter_on_project_custom_field
                 field = ProjectCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')
                 CustomValue.create!(:custom_field => field, :customized => Project.find(3), :value => 'Foo')
                 CustomValue.create!(:custom_field => field, :customized => Project.find(5), :value => 'Foo')
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 filter_name = "project.cf_#{field.id}"
                 assert_include filter_name, query.available_filters.keys
                 query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
                 assert_equal [3, 5], find_issues_with_query(query).map(&:project_id).uniq.sort
               end
               def test_filter_on_author_custom_field
                 field = UserCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')
                 CustomValue.create!(:custom_field => field, :customized => User.find(3), :value => 'Foo')
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 filter_name = "author.cf_#{field.id}"
                 assert_include filter_name, query.available_filters.keys
                 query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
                 assert_equal [3], find_issues_with_query(query).map(&:author_id).uniq.sort
               end
               def test_filter_on_assigned_to_custom_field
                 field = UserCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')
                 CustomValue.create!(:custom_field => field, :customized => User.find(3), :value => 'Foo')
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 filter_name = "assigned_to.cf_#{field.id}"
                 assert_include filter_name, query.available_filters.keys
                 query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
                 assert_equal [3], find_issues_with_query(query).map(&:assigned_to_id).uniq.sort
               end
               def test_filter_on_fixed_version_custom_field
                 field = VersionCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')
                 CustomValue.create!(:custom_field => field, :customized => Version.find(2), :value => 'Foo')
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 filter_name = "fixed_version.cf_#{field.id}"
                 assert_include filter_name, query.available_filters.keys
                 query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
                 assert_equal [2], find_issues_with_query(query).map(&:fixed_version_id).uniq.sort
               end
               def test_filter_on_relations_with_a_specific_issue
                 IssueRelation.delete_all
                 IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))
                 IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '=', :values => ['1']}}
                 assert_equal [2, 3], find_issues_with_query(query).map(&:id).sort
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '=', :values => ['2']}}
                 assert_equal [1], find_issues_with_query(query).map(&:id).sort
               end
               def test_filter_on_relations_with_any_issues_in_a_project
                 IssueRelation.delete_all
                 with_settings :cross_project_issue_relations => '1' do
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(2).issues.first)
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first)
                 end
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '=p', :values => ['2']}}
                 assert_equal [1, 2], find_issues_with_query(query).map(&:id).sort
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '=p', :values => ['3']}}
                 assert_equal [1], find_issues_with_query(query).map(&:id).sort
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '=p', :values => ['4']}}
                 assert_equal [], find_issues_with_query(query).map(&:id).sort
               end
               def test_filter_on_relations_with_any_issues_not_in_a_project
                 IssueRelation.delete_all
                 with_settings :cross_project_issue_relations => '1' do
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)
                   #IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(1).issues.first)
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first)
                 end
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '=!p', :values => ['1']}}
                 assert_equal [1], find_issues_with_query(query).map(&:id).sort
               end
               def test_filter_on_relations_with_no_issues_in_a_project
                 IssueRelation.delete_all
                 with_settings :cross_project_issue_relations => '1' do
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(3).issues.first)
                   IssueRelation.create!(:relation_type => "relates", :issue_to => Project.find(2).issues.first, :issue_from => Issue.find(3))
                 end
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '!p', :values => ['2']}}
                 ids = find_issues_with_query(query).map(&:id).sort
                 assert_include 2, ids
                 assert_not_include 1, ids
                 assert_not_include 3, ids
               end
               def test_filter_on_relations_with_no_issues
                 IssueRelation.delete_all
                 IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))
                 IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '!*', :values => ['']}}
                 ids = find_issues_with_query(query).map(&:id)
                 assert_equal [], ids & [1, 2, 3]
                 assert_include 4, ids
               end
               def test_filter_on_relations_with_any_issues
                 IssueRelation.delete_all
                 IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))
                 IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))
-                query = Query.new(:name => '_')
+                query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '*', :values => ['']}}
                 assert_equal [1, 2, 3], find_issues_with_query(query).map(&:id).sort
               end
               def test_statement_should_be_nil_with_no_filters
-                q = Query.new(:name => '_')
+                q = IssueQuery.new(:name => '_')
                 q.filters = {}
                 assert q.valid?
                 assert_nil q.statement
               end
               def test_default_columns
-                q = Query.new
+                q = IssueQuery.new
                 assert q.columns.any?
                 assert q.inline_columns.any?
                 assert q.block_columns.empty?
               end
               def test_set_column_names
-                q = Query.new
+                q = IssueQuery.new
                 q.column_names = ['tracker', :subject, '', 'unknonw_column']
                 assert_equal [:tracker, :subject], q.columns.collect {|c| c.name}
                 c = q.columns.first
                 assert q.has_column?(c)
               end
               def test_inline_and_block_columns
-                q = Query.new
+                q = IssueQuery.new
                 q.column_names = ['subject', 'description', 'tracker']
                 assert_equal [:subject, :tracker], q.inline_columns.map(&:name)
                 assert_equal [:description], q.block_columns.map(&:name)
               end
               def test_custom_field_columns_should_be_inline
-                q = Query.new
+                q = IssueQuery.new
                 columns = q.available_columns.select {|column| column.is_a? QueryCustomFieldColumn}
                 assert columns.any?
                 assert_nil columns.detect {|column| !column.inline?}
               end
               def test_query_should_preload_spent_hours
-                q = Query.new(:name => '_', :column_names => [:subject, :spent_hours])
+                q = IssueQuery.new(:name => '_', :column_names => [:subject, :spent_hours])
                 assert q.has_column?(:spent_hours)
                 issues = q.issues
                 assert_not_nil issues.first.instance_variable_get("@spent_hours")
               end
               def test_groupable_columns_should_include_custom_fields
-                q = Query.new
+                q = IssueQuery.new
                 column = q.groupable_columns.detect {|c| c.name == :cf_1}
                 assert_not_nil column
                 assert_kind_of QueryCustomFieldColumn, column
               end
               def test_groupable_columns_should_not_include_multi_custom_fields
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
-                q = Query.new
+                q = IssueQuery.new
                 column = q.groupable_columns.detect {|c| c.name == :cf_1}
                 assert_nil column
               end
               def test_groupable_columns_should_include_user_custom_fields
                 cf = IssueCustomField.create!(:name => 'User', :is_for_all => true, :tracker_ids => [1], :field_format => 'user')
-                q = Query.new
+                q = IssueQuery.new
                 assert q.groupable_columns.detect {|c| c.name == "cf_#{cf.id}".to_sym}
               end
               def test_groupable_columns_should_include_version_custom_fields
                 cf = IssueCustomField.create!(:name => 'User', :is_for_all => true, :tracker_ids => [1], :field_format => 'version')
-                q = Query.new
+                q = IssueQuery.new
                 assert q.groupable_columns.detect {|c| c.name == "cf_#{cf.id}".to_sym}
               end
               def test_grouped_with_valid_column
-                q = Query.new(:group_by => 'status')
+                q = IssueQuery.new(:group_by => 'status')
                 assert q.grouped?
                 assert_not_nil q.group_by_column
                 assert_equal :status, q.group_by_column.name
                 assert_not_nil q.group_by_statement
                 assert_equal 'status', q.group_by_statement
               end
               def test_grouped_with_invalid_column
-                q = Query.new(:group_by => 'foo')
+                q = IssueQuery.new(:group_by => 'foo')
                 assert !q.grouped?
                 assert_nil q.group_by_column
                 assert_nil q.group_by_statement
               end
               def test_sortable_columns_should_sort_assignees_according_to_user_format_setting
                 with_settings :user_format => 'lastname_coma_firstname' do
-                  q = Query.new
+                  q = IssueQuery.new
                   assert q.sortable_columns.has_key?('assigned_to')
                   assert_equal %w(users.lastname users.firstname users.id), q.sortable_columns['assigned_to']
                 end
               end
               def test_sortable_columns_should_sort_authors_according_to_user_format_setting
                 with_settings :user_format => 'lastname_coma_firstname' do
-                  q = Query.new
+                  q = IssueQuery.new
                   assert q.sortable_columns.has_key?('author')
                   assert_equal %w(authors.lastname authors.firstname authors.id), q.sortable_columns['author']
                 end
               end
               def test_sortable_columns_should_include_custom_field
-                q = Query.new
+                q = IssueQuery.new
                 assert q.sortable_columns['cf_1']
               end
               def test_sortable_columns_should_not_include_multi_custom_field
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
-                q = Query.new
+                q = IssueQuery.new
                 assert !q.sortable_columns['cf_1']
               end
               def test_default_sort
-                q = Query.new
+                q = IssueQuery.new
                 assert_equal [], q.sort_criteria
               end
               def test_set_sort_criteria_with_hash
-                q = Query.new
+                q = IssueQuery.new
                 q.sort_criteria = {'0' => ['priority', 'desc'], '2' => ['tracker']}
                 assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria
               end
               def test_set_sort_criteria_with_array
-                q = Query.new
+                q = IssueQuery.new
                 q.sort_criteria = [['priority', 'desc'], 'tracker']
                 assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria
               end
               def test_create_query_with_sort
-                q = Query.new(:name => 'Sorted')
+                q = IssueQuery.new(:name => 'Sorted')
                 q.sort_criteria = [['priority', 'desc'], 'tracker']
                 assert q.save
                 q.reload
                 assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria
               end
               def test_sort_by_string_custom_field_asc
-                q = Query.new
+                q = IssueQuery.new
                 c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }
                 assert c
                 assert c.sortable
                 issues = Issue.includes([:assigned_to, :status, :tracker, :project, :priority]).where(
                      q.statement
                    ).order("#{c.sortable} ASC").all
                 values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}
                 assert !values.empty?
                 assert_equal values.sort, values
               end
               def test_sort_by_string_custom_field_desc
-                q = Query.new
+                q = IssueQuery.new
                 c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }
                 assert c
                 assert c.sortable
                 issues = Issue.includes([:assigned_to, :status, :tracker, :project, :priority]).where(
                      q.statement
                    ).order("#{c.sortable} DESC").all
                 values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}
                 assert !values.empty?
                 assert_equal values.sort.reverse, values
               end
               def test_sort_by_float_custom_field_asc
-                q = Query.new
+                q = IssueQuery.new
                 c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'float' }
                 assert c
                 assert c.sortable
                 issues = Issue.includes([:assigned_to, :status, :tracker, :project, :priority]).where(
                      q.statement
                    ).order("#{c.sortable} ASC").all
                 values = issues.collect {|i| begin; Kernel.Float(i.custom_value_for(c.custom_field).to_s); rescue; nil; end}.compact
                 assert !values.empty?
                 assert_equal values.sort, values
               end
               def test_invalid_query_should_raise_query_statement_invalid_error
-                q = Query.new
+                q = IssueQuery.new
                 assert_raise Query::StatementInvalid do
                   q.issues(:conditions => "foo = 1")
                 end
               end
               def test_issue_count
-                q = Query.new(:name => '_')
+                q = IssueQuery.new(:name => '_')
                 issue_count = q.issue_count
                 assert_equal q.issues.size, issue_count
               end
               def test_issue_count_with_archived_issues
                 p = Project.generate! do |project|
                   project.status = Project::STATUS_ARCHIVED
                 end
                 i = Issue.generate!( :project => p, :tracker => p.trackers.first )
                 assert !i.visible?
                 test_issue_count
               end
               def test_issue_count_by_association_group
-                q = Query.new(:name => '_', :group_by => 'assigned_to')
+                q = IssueQuery.new(:name => '_', :group_by => 'assigned_to')
                 count_by_group = q.issue_count_by_group
                 assert_kind_of Hash, count_by_group
                 assert_equal %w(NilClass User), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
                 assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
                 assert count_by_group.has_key?(User.find(3))
               end
               def test_issue_count_by_list_custom_field_group
-                q = Query.new(:name => '_', :group_by => 'cf_1')
+                q = IssueQuery.new(:name => '_', :group_by => 'cf_1')
                 count_by_group = q.issue_count_by_group
                 assert_kind_of Hash, count_by_group
                 assert_equal %w(NilClass String), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
                 assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
                 assert count_by_group.has_key?('MySQL')
               end
               def test_issue_count_by_date_custom_field_group
-                q = Query.new(:name => '_', :group_by => 'cf_8')
+                q = IssueQuery.new(:name => '_', :group_by => 'cf_8')
                 count_by_group = q.issue_count_by_group
                 assert_kind_of Hash, count_by_group
                 assert_equal %w(Date NilClass), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
                 assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
               end
               def test_issue_count_with_nil_group_only
                 Issue.update_all("assigned_to_id = NULL")
-                q = Query.new(:name => '_', :group_by => 'assigned_to')
+                q = IssueQuery.new(:name => '_', :group_by => 'assigned_to')
                 count_by_group = q.issue_count_by_group
                 assert_kind_of Hash, count_by_group
                 assert_equal 1, count_by_group.keys.size
                 assert_nil count_by_group.keys.first
               end
               def test_issue_ids
-                q = Query.new(:name => '_')
+                q = IssueQuery.new(:name => '_')
                 order = "issues.subject, issues.id"
                 issues = q.issues(:order => order)
                 assert_equal issues.map(&:id), q.issue_ids(:order => order)
               end
               def test_label_for
                 set_language_if_valid 'en'
-                q = Query.new
+                q = IssueQuery.new
                 assert_equal 'Assignee', q.label_for('assigned_to_id')
               end
               def test_label_for_fr
                 set_language_if_valid 'fr'
-                q = Query.new
+                q = IssueQuery.new
                 s = "Assign\xc3\xa9 \xc3\xa0"
                 s.force_encoding('UTF-8') if s.respond_to?(:force_encoding)
                 assert_equal s, q.label_for('assigned_to_id')
               end
               def test_editable_by
                 admin = User.find(1)
                 manager = User.find(2)
                 developer = User.find(3)
                 # Public query on project 1
-                q = Query.find(1)
+                q = IssueQuery.find(1)
                 assert q.editable_by?(admin)
                 assert q.editable_by?(manager)
                 assert !q.editable_by?(developer)
                 # Private query on project 1
-                q = Query.find(2)
+                q = IssueQuery.find(2)
                 assert q.editable_by?(admin)
                 assert !q.editable_by?(manager)
                 assert q.editable_by?(developer)
                 # Private query for all projects
-                q = Query.find(3)
+                q = IssueQuery.find(3)
                 assert q.editable_by?(admin)
                 assert !q.editable_by?(manager)
                 assert q.editable_by?(developer)
                 # Public query for all projects
-                q = Query.find(4)
+                q = IssueQuery.find(4)
                 assert q.editable_by?(admin)
                 assert !q.editable_by?(manager)
                 assert !q.editable_by?(developer)
               end
               def test_visible_scope
-                query_ids = Query.visible(User.anonymous).map(&:id)
+                query_ids = IssueQuery.visible(User.anonymous).map(&:id)
                 assert query_ids.include?(1), 'public query on public project was not visible'
                 assert query_ids.include?(4), 'public query for all projects was not visible'
                 assert !query_ids.include?(2), 'private query on public project was visible'
                 assert !query_ids.include?(3), 'private query for all projects was visible'
                 assert !query_ids.include?(7), 'public query on private project was visible'
               end
               context "#available_filters" do
                 setup do
-                  @query = Query.new(:name => "_")
+                  @query = IssueQuery.new(:name => "_")
                 end
                 should "include users of visible projects in cross-project view" do
                   users = @query.available_filters["assigned_to_id"]
                   assert_not_nil users
                   assert users[:values].map{|u|u[1]}.include?("3")
                 end
                 should "include users of subprojects" do
                   user1 = User.generate!
                   user2 = User.generate!
                   project = Project.find(1)
                   Member.create!(:principal => user1, :project => project.children.visible.first, :role_ids => [1])
                   @query.project = project
                   users = @query.available_filters["assigned_to_id"]
                   assert_not_nil users
                   assert users[:values].map{|u|u[1]}.include?(user1.id.to_s)
                   assert !users[:values].map{|u|u[1]}.include?(user2.id.to_s)
                 end
                 should "include visible projects in cross-project view" do
                   projects = @query.available_filters["project_id"]
                   assert_not_nil projects
                   assert projects[:values].map{|u|u[1]}.include?("1")
                 end
                 context "'member_of_group' filter" do
                   should "be present" do
                     assert @query.available_filters.keys.include?("member_of_group")
                   end
                   should "be an optional list" do
                     assert_equal :list_optional, @query.available_filters["member_of_group"][:type]
                   end
                   should "have a list of the groups as values" do
                     Group.destroy_all # No fixtures
                     group1 = Group.generate!.reload
                     group2 = Group.generate!.reload
                     expected_group_list = [
                                            [group1.name, group1.id.to_s],
                                            [group2.name, group2.id.to_s]
                                           ]
                     assert_equal expected_group_list.sort, @query.available_filters["member_of_group"][:values].sort
                   end
                 end
                 context "'assigned_to_role' filter" do
                   should "be present" do
                     assert @query.available_filters.keys.include?("assigned_to_role")
                   end
                   should "be an optional list" do
                     assert_equal :list_optional, @query.available_filters["assigned_to_role"][:type]
                   end
                   should "have a list of the Roles as values" do
                     assert @query.available_filters["assigned_to_role"][:values].include?(['Manager','1'])
                     assert @query.available_filters["assigned_to_role"][:values].include?(['Developer','2'])
                     assert @query.available_filters["assigned_to_role"][:values].include?(['Reporter','3'])
                   end
                   should "not include the built in Roles as values" do
                     assert ! @query.available_filters["assigned_to_role"][:values].include?(['Non member','4'])
                     assert ! @query.available_filters["assigned_to_role"][:values].include?(['Anonymous','5'])
                   end
                 end
               end
               context "#statement" do
                 context "with 'member_of_group' filter" do
                   setup do
                     Group.destroy_all # No fixtures
                     @user_in_group = User.generate!
                     @second_user_in_group = User.generate!
                     @user_in_group2 = User.generate!
                     @user_not_in_group = User.generate!
                     @group = Group.generate!.reload
                     @group.users << @user_in_group
                     @group.users << @second_user_in_group
                     @group2 = Group.generate!.reload
                     @group2.users << @user_in_group2
                   end
                   should "search assigned to for users in the group" do
-                    @query = Query.new(:name => '_')
+                    @query = IssueQuery.new(:name => '_')
                     @query.add_filter('member_of_group', '=', [@group.id.to_s])
                     assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IN ('#{@user_in_group.id}','#{@second_user_in_group.id}')"
                     assert_find_issues_with_query_is_successful @query
                   end
                   should "search not assigned to any group member (none)" do
-                    @query = Query.new(:name => '_')
+                    @query = IssueQuery.new(:name => '_')
                     @query.add_filter('member_of_group', '!*', [''])
                     # Users not in a group
                     assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IS NULL OR #{Issue.table_name}.assigned_to_id NOT IN ('#{@user_in_group.id}','#{@second_user_in_group.id}','#{@user_in_group2.id}')"
                     assert_find_issues_with_query_is_successful @query
                   end
                   should "search assigned to any group member (all)" do
-                    @query = Query.new(:name => '_')
+                    @query = IssueQuery.new(:name => '_')
                     @query.add_filter('member_of_group', '*', [''])
                     # Only users in a group
                     assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IN ('#{@user_in_group.id}','#{@second_user_in_group.id}','#{@user_in_group2.id}')"
                     assert_find_issues_with_query_is_successful @query
                   end
                   should "return an empty set with = empty group" do
                     @empty_group = Group.generate!
-                    @query = Query.new(:name => '_')
+                    @query = IssueQuery.new(:name => '_')
                     @query.add_filter('member_of_group', '=', [@empty_group.id.to_s])
                     assert_equal [], find_issues_with_query(@query)
                   end
                   should "return issues with ! empty group" do
                     @empty_group = Group.generate!
-                    @query = Query.new(:name => '_')
+                    @query = IssueQuery.new(:name => '_')
                     @query.add_filter('member_of_group', '!', [@empty_group.id.to_s])
                     assert_find_issues_with_query_is_successful @query
                   end
                 end
                 context "with 'assigned_to_role' filter" do
                   setup do
                     @manager_role = Role.find_by_name('Manager')
                     @developer_role = Role.find_by_name('Developer')
                     @project = Project.generate!
                     @manager = User.generate!
                     @developer = User.generate!
                     @boss = User.generate!
                     @guest = User.generate!
                     User.add_to_project(@manager, @project, @manager_role)
                     User.add_to_project(@developer, @project, @developer_role)
                     User.add_to_project(@boss, @project, [@manager_role, @developer_role])
                     @issue1 = Issue.generate!(:project => @project, :assigned_to_id => @manager.id)
                     @issue2 = Issue.generate!(:project => @project, :assigned_to_id => @developer.id)
                     @issue3 = Issue.generate!(:project => @project, :assigned_to_id => @boss.id)
                     @issue4 = Issue.generate!(:project => @project, :assigned_to_id => @guest.id)
                     @issue5 = Issue.generate!(:project => @project)
                   end
                   should "search assigned to for users with the Role" do
-                    @query = Query.new(:name => '_', :project => @project)
+                    @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])
                     assert_query_result [@issue1, @issue3], @query
                   end
                   should "search assigned to for users with the Role on the issue project" do
                     other_project = Project.generate!
                     User.add_to_project(@developer, other_project, @manager_role)
-                    @query = Query.new(:name => '_', :project => @project)
+                    @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])
                     assert_query_result [@issue1, @issue3], @query
                   end
                   should "return an empty set with empty role" do
                     @empty_role = Role.generate!
-                    @query = Query.new(:name => '_', :project => @project)
+                    @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '=', [@empty_role.id.to_s])
                     assert_query_result [], @query
                   end
                   should "search assigned to for users without the Role" do
-                    @query = Query.new(:name => '_', :project => @project)
+                    @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '!', [@manager_role.id.to_s])
                     assert_query_result [@issue2, @issue4, @issue5], @query
                   end
                   should "search assigned to for users not assigned to any Role (none)" do
-                    @query = Query.new(:name => '_', :project => @project)
+                    @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '!*', [''])
                     assert_query_result [@issue4, @issue5], @query
                   end
                   should "search assigned to for users assigned to any Role (all)" do
-                    @query = Query.new(:name => '_', :project => @project)
+                    @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '*', [''])
                     assert_query_result [@issue1, @issue2, @issue3], @query
                   end
                   should "return issues with ! empty role" do
                     @empty_role = Role.generate!
-                    @query = Query.new(:name => '_', :project => @project)
+                    @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '!', [@empty_role.id.to_s])
                     assert_query_result [@issue1, @issue2, @issue3, @issue4, @issue5], @query
                   end
                 end
               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