jro_apps/redmine Commit - r6345:3605a1813705

157

:include => :project

157

:include => :project

158

}

158

}

159

}

159

}

160

161

def initialize(attributes = nil)

161

def initialize(attributes = nil)

162

super attributes

162

super attributes

163

self.filters ||= { 'status_id' => {:operator => "o", :values => [""]} }

163

self.filters ||= { 'status_id' => {:operator => "o", :values => [""]} }

172

filters.each_key do |field|

172

filters.each_key do |field|

173

if values_for(field)

173

if values_for(field)

174

case type_for(field)

174

case type_for(field)

175

when :integer

175

when :integer

176

errors.add(label_for(field), :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^\d+$/) }

176

errors.add(label_for(field), :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^\d+$/) }

177

when :float

177

when :float

178

errors.add(label_for(field), :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^\d+(\.\d*)?$/) }

178

errors.add(label_for(field), :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^\d+(\.\d*)?$/) }

179

when :date, :date_past

179

when :date, :date_past

180

case operator_for(field)

180

case operator_for(field)

185

end

185

end

186

end

186

end

187

end

187

end

188

189

errors.add label_for(field), :blank unless

189

errors.add label_for(field), :blank unless

190

# filter requires one or more values

190

# filter requires one or more values

191

(values_for(field) and !values_for(field).first.blank?) or

191

(values_for(field) and !values_for(field).first.blank?) or

193

["o", "c", "!*", "*", "t", "w"].include? operator_for(field)

193

["o", "c", "!*", "*", "t", "w"].include? operator_for(field)

194

end if filters

194

end if filters

195

end

195

end

196

197

# Returns true if the query is visible to +user+ or the current user.

197

# Returns true if the query is visible to +user+ or the current user.

198

def visible?(user=User.current)

198

def visible?(user=User.current)

199

(project.nil? || user.allowed_to?(:view_issues, project)) && (self.is_public? || self.user_id == user.id)

199

(project.nil? || user.allowed_to?(:view_issues, project)) && (self.is_public? || self.user_id == user.id)

242

end

242

end

243

end

243

end

244

users = principals.select {|p| p.is_a?(User)}

244

users = principals.select {|p| p.is_a?(User)}

245

246

assigned_to_values = []

246

assigned_to_values = []

247

assigned_to_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?

247

assigned_to_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?

248

assigned_to_values += (Setting.issue_group_assignment? ? principals : users).collect{|s| [s.name, s.id.to_s] }

248

assigned_to_values += (Setting.issue_group_assignment? ? principals : users).collect{|s| [s.name, s.id.to_s] }

249

@available_filters["assigned_to_id"] = { :type => :list_optional, :order => 4, :values => assigned_to_values } unless assigned_to_values.empty?

249

@available_filters["assigned_to_id"] = { :type => :list_optional, :order => 4, :values => assigned_to_values } unless assigned_to_values.empty?

250

251

author_values = []

251

author_values = []

252

author_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?

252

author_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?

253

author_values += users.collect{|s| [s.name, s.id.to_s] }

253

author_values += users.collect{|s| [s.name, s.id.to_s] }

324

def has_filter?(field)

324

def has_filter?(field)

325

filters and filters[field]

325

filters and filters[field]

326

end

326

end

327

328

def type_for(field)

328

def type_for(field)

329

available_filters[field][:type] if available_filters.has_key?(field)

329

available_filters[field][:type] if available_filters.has_key?(field)

330

end

330

end

336

def values_for(field)

336

def values_for(field)

337

has_filter?(field) ? filters[field][:values] : nil

337

has_filter?(field) ? filters[field][:values] : nil

338

end

338

end

339

340

def value_for(field, index=0)

340

def value_for(field, index=0)

341

(values_for(field) || [])[index]

341

(values_for(field) || [])[index]

342

end

342

end

349

def available_columns

349

def available_columns

350

return @available_columns if @available_columns

350

return @available_columns if @available_columns

351

@available_columns = Query.available_columns

351

@available_columns = Query.available_columns

352

@available_columns += (project ?

352

@available_columns += (project ?

353

project.all_issue_custom_fields :

353

project.all_issue_custom_fields :

354

IssueCustomField.find(:all)

354

IssueCustomField.find(:all)

355

).collect {|cf| QueryCustomFieldColumn.new(cf) }

355

).collect {|cf| QueryCustomFieldColumn.new(cf) }

577

rescue ::ActiveRecord::StatementInvalid => e

577

rescue ::ActiveRecord::StatementInvalid => e

578

raise StatementInvalid.new(e.message)

578

raise StatementInvalid.new(e.message)

579

end

579

end

580

581

def sql_for_watcher_id_field(field, operator, value)

581

def sql_for_watcher_id_field(field, operator, value)

582

db_table = Watcher.table_name

582

db_table = Watcher.table_name

583

"#{Issue.table_name}.id #{ operator == '=' ? 'IN' : 'NOT IN' } (SELECT #{db_table}.watchable_id FROM #{db_table} WHERE #{db_table}.watchable_type='Issue' AND " +

583

"#{Issue.table_name}.id #{ operator == '=' ? 'IN' : 'NOT IN' } (SELECT #{db_table}.watchable_id FROM #{db_table} WHERE #{db_table}.watchable_type='Issue' AND " +

584

sql_for_field(field, '=', value, db_table, 'user_id') + ')'

584

sql_for_field(field, '=', value, db_table, 'user_id') + ')'

585

end

585

end

586

587

def sql_for_member_of_group_field(field, operator, value)

587

def sql_for_member_of_group_field(field, operator, value)

588

if operator == '*' # Any group

588

if operator == '*' # Any group

589

groups = Group.all

589

groups = Group.all

605

606

'(' + sql_for_field("assigned_to_id", operator, members_of_groups, Issue.table_name, "assigned_to_id", false) + ')'

606

'(' + sql_for_field("assigned_to_id", operator, members_of_groups, Issue.table_name, "assigned_to_id", false) + ')'

607

end

607

end

608

609

def sql_for_assigned_to_role_field(field, operator, value)

609

def sql_for_assigned_to_role_field(field, operator, value)

610

if operator == "*" # Any Role

610

if operator == "*" # Any Role

611

roles = Role.givable

611

roles = Role.givable

629

end

629

end

630

631

private

631

private

632

633

def sql_for_custom_field(field, operator, value, custom_field_id)

633

def sql_for_custom_field(field, operator, value, custom_field_id)

634

db_table = CustomValue.table_name

634

db_table = CustomValue.table_name

635

db_field = 'value'

635

db_field = 'value'

636

"#{Issue.table_name}.id IN (SELECT #{Issue.table_name}.id FROM #{Issue.table_name} LEFT OUTER JOIN #{db_table} ON #{db_table}.customized_type='Issue' AND #{db_table}.customized_id=#{Issue.table_name}.id AND #{db_table}.custom_field_id=#{custom_field_id} WHERE " +

636

"#{Issue.table_name}.id IN (SELECT #{Issue.table_name}.id FROM #{Issue.table_name} LEFT OUTER JOIN #{db_table} ON #{db_table}.customized_type='Issue' AND #{db_table}.customized_id=#{Issue.table_name}.id AND #{db_table}.custom_field_id=#{custom_field_id} WHERE " +

637

sql_for_field(field, operator, value, db_table, db_field, true) + ')'

637

sql_for_field(field, operator, value, db_table, db_field, true) + ')'

638

end

638

end

639

640

# Helper method to generate the WHERE sql for a +field+, +operator+ and a +value+

640

# Helper method to generate the WHERE sql for a +field+, +operator+ and a +value+

641

def sql_for_field(field, operator, value, db_table, db_field, is_custom_filter=false)

641

def sql_for_field(field, operator, value, db_table, db_field, is_custom_filter=false)

642

sql = ''

642

sql = ''

760

@available_filters["cf_#{field.id}"] = options.merge({ :name => field.name })

760

@available_filters["cf_#{field.id}"] = options.merge({ :name => field.name })

761

end

761

end

762

end

762

end

763

764

# Returns a SQL clause for a date or datetime field.

764

# Returns a SQL clause for a date or datetime field.

765

def date_clause(table, field, from, to)

765

def date_clause(table, field, from, to)

766

s = []

766

s = []

772

end

772

end

773

s.join(' AND ')

773

s.join(' AND ')

774

end

774

end

775

776

# Returns a SQL clause for a date or datetime field using relative dates.

776

# Returns a SQL clause for a date or datetime field using relative dates.

777

def relative_date_clause(table, field, days_from, days_to)

777

def relative_date_clause(table, field, days_from, days_to)

778

date_clause(table, field, (days_from ? Date.today + days_from : nil), (days_to ? Date.today + days_to : nil))

778

date_clause(table, field, (days_from ? Date.today + days_from : nil), (days_to ? Date.today + days_to : nil))

	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

                   :include => :project
                 }
               }
               def initialize(attributes = nil)
                 super attributes
                 self.filters ||= { 'status_id' => {:operator => "o", :values => [""]} }
                 filters.each_key do |field|
                   if values_for(field)
                     case type_for(field)
                     when :integer
                       errors.add(label_for(field), :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^\d+$/) }
                     when :float
                       errors.add(label_for(field), :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^\d+(\.\d*)?$/) }
                     when :date, :date_past
                       case operator_for(field)
                       end
                     end
                   end
                   errors.add label_for(field), :blank unless
                       # filter requires one or more values
                       (values_for(field) and !values_for(field).first.blank?) or
                       ["o", "c", "!*", "*", "t", "w"].include? operator_for(field)
                 end if filters
               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
                 end
                 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] }
               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 values_for(field)
                 has_filter?(field) ? filters[field][:values] : nil
               end
               def value_for(field, index=0)
                 (values_for(field) || [])[index]
               end
               def available_columns
                 return @available_columns if @available_columns
                 @available_columns = Query.available_columns
                 @available_columns += (project ?
                                         project.all_issue_custom_fields :
                                         IssueCustomField.find(:all)
                                        ).collect {|cf| QueryCustomFieldColumn.new(cf) }
               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
                 '(' + 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)
                 if operator == "*" # Any Role
                   roles = Role.givable
               end
               private
               def sql_for_custom_field(field, operator, value, custom_field_id)
                 db_table = CustomValue.table_name
                 db_field = 'value'
                 "#{Issue.table_name}.id IN (SELECT #{Issue.table_name}.id FROM #{Issue.table_name} LEFT OUTER JOIN #{db_table} ON #{db_table}.customized_type='Issue' AND #{db_table}.customized_id=#{Issue.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 = ''
                   @available_filters["cf_#{field.id}"] = options.merge({ :name => field.name })
                 end
               end
               # Returns a SQL clause for a date or datetime field.
               def date_clause(table, field, from, to)
                 s = []
                 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))