jro_apps/redmine Commit - r15245:5d31eb2495c2

Don't generate pagination links with params....

Jean-Philippe Lang -

r15245:5d31eb2495c2

parent child

Context file:

r15245:5d31eb2495c2

Collapse all files

lib/redmine/pagination.rb +1 -1

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2016  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 Redmine
               module Pagination
                 class Paginator
                   attr_reader :item_count, :per_page, :page, :page_param
                   def initialize(*args)
                     if args.first.is_a?(ActionController::Base)
                       args.shift
                       ActiveSupport::Deprecation.warn "Paginator no longer takes a controller instance as the first argument. Remove it from #new arguments."
                     end
                     item_count, per_page, page, page_param = *args
                     @item_count = item_count
                     @per_page = per_page
                     page = (page || 1).to_i
                     if page < 1
                       page = 1
                     end
                     @page = page
                     @page_param = page_param || :page
                   end
                   def offset
                     (page - 1) * per_page
                   end
                   def first_page
                     if item_count > 0
                     end
                   end
                   def previous_page
                     if page > 1
                       page - 1
                     end
                   end
                   def next_page
                     if last_item < item_count
                       page + 1
                     end
                   end
                   def last_page
                     if item_count > 0
                       (item_count - 1) / per_page + 1
                     end
                   end
                   def multiple_pages?
                     per_page < item_count
                   end
                   def first_item
                     item_count == 0 ? 0 : (offset + 1)
                   end
                   def last_item
                     l = first_item + per_page - 1
                     l > item_count ? item_count : l
                   end
                   def linked_pages
                     pages = []
                     if item_count > 0
                       pages += [first_page, page, last_page]
                       pages += ((page-2)..(page+2)).to_a.select {|p| p > first_page && p < last_page}
                     end
                     pages = pages.compact.uniq.sort
                     if pages.size > 1
                       pages
                     else
                       []
                     end
                   end
                   def items_per_page
                     ActiveSupport::Deprecation.warn "Paginator#items_per_page will be removed. Use #per_page instead."
                     per_page
                   end
                   def current
                     ActiveSupport::Deprecation.warn "Paginator#current will be removed. Use .offset instead of .current.offset."
                     self
                   end
                 end
                 # Paginates the given scope or model. Returns a Paginator instance and
                 # the collection of objects for the current page.
                 #
                 # Options:
                 #   :parameter     name of the page parameter
                 #
                 # Examples:
                 #   @user_pages, @users = paginate User.where(:status => 1)
                 #
                 def paginate(scope, options={})
                   options = options.dup
                   paginator = paginator(scope.count, options)
                   collection = scope.limit(paginator.per_page).offset(paginator.offset).to_a
                   return paginator, collection
                 end
                 def paginator(item_count, options={})
                   options.assert_valid_keys :parameter, :per_page
                   page_param = options[:parameter] || :page
                   page = (params[page_param] || 1).to_i
                   per_page = options[:per_page] || per_page_option
                   Paginator.new(item_count, per_page, page, page_param)
                 end
                 module Helper
                   include Redmine::I18n
                   # Renders the pagination links for the given paginator.
                   #
                   # Options:
                   #   :per_page_links    if set to false, the "Per page" links are not rendered
                   #
                   def pagination_links_full(*args)
                     pagination_links_each(*args) do |text, parameters, options|
                       if block_given?
                         yield text, parameters, options
                       else
-                        link_to text, params.merge(parameters), options
+                        link_to text, {:params => request.query_parameters.merge(parameters)}, options
                       end
                     end
                   end
                   # Yields the given block with the text and parameters
                   # for each pagination link and returns a string that represents the links
                   def pagination_links_each(paginator, count=nil, options={}, &block)
                     options.assert_valid_keys :per_page_links
                     per_page_links = options.delete(:per_page_links)
                     per_page_links = false if count.nil?
                     page_param = paginator.page_param
                     html = '<ul class="pages">'
                     if paginator.multiple_pages?
                       # \xc2\xab(utf-8) = &#171;
                       text = "\xc2\xab " + l(:label_previous)
                       if paginator.previous_page
                         html << content_tag('li',
                                             yield(text, {page_param => paginator.previous_page},
                                                   :accesskey => accesskey(:previous)),
                                             :class => 'previous page')
                       else
                         html << content_tag('li', content_tag('span', text), :class => 'previous')
                       end
                     end
                     previous = nil
                     paginator.linked_pages.each do |page|
                       if previous && previous != page - 1
                         html << content_tag('li', content_tag('span', '&hellip;'.html_safe), :class => 'spacer')
                       end
                       if page == paginator.page
                         html << content_tag('li', content_tag('span', page.to_s), :class => 'current')
                       else
                         html << content_tag('li',
                                             yield(page.to_s, {page_param => page}),
                                             :class => 'page')
                       end
                       previous = page
                     end
                     if paginator.multiple_pages?
                       # \xc2\xbb(utf-8) = &#187;
                       text = l(:label_next) + " \xc2\xbb"
                       if paginator.next_page
                         html << content_tag('li',
                                             yield(text, {page_param => paginator.next_page},
                                                   :accesskey => accesskey(:next)),
                                             :class => 'next page')
                       else
                         html << content_tag('li', content_tag('span', text), :class => 'next')
                       end
                     end
                     html << '</ul>'
                     info = ''.html_safe
                     info << content_tag('span', "(#{paginator.first_item}-#{paginator.last_item}/#{paginator.item_count})", :class => 'items') + ' '
                     if per_page_links != false && links = per_page_links(paginator, &block)
                       info << content_tag('span', links.to_s, :class => 'per-page')
                     end
                     html << content_tag('span', info)
                     html.html_safe
                   end
                   # Renders the "Per page" links.
                   def per_page_links(paginator, &block)
                     values = per_page_options(paginator.per_page, paginator.item_count)
                     if values.any?
                       links = values.collect do |n|
                         if n == paginator.per_page
                           content_tag('span', n.to_s, :class => 'selected')
                         else
                           yield(n, :per_page => n, paginator.page_param => nil)
                         end
                       end
                       l(:label_display_per_page, links.join(', ')).html_safe
                     end
                   end
                   def per_page_options(selected=nil, item_count=nil)
                     options = Setting.per_page_options_array
                     if item_count && options.any?
                       if item_count > options.first
                         max = options.detect {|value| value >= item_count} || item_count
                       else
                         max = item_count
                       end
                       options = options.select {|value| value <= max || value == selected}
                     end
                     if options.empty? || (options.size == 1 && options.first == selected)
                       []
                     else
                       options
                     end
                   end
                 end
               end
             end

test/integration/issues_test.rb +4 -4

             # Redmine - project management software
             # Copyright (C) 2006-2016  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 IssuesTest < Redmine::IntegrationTest
               fixtures :projects,
                        :users, :email_addresses,
                        :roles,
                        :members,
                        :member_roles,
                        :trackers,
                        :projects_trackers,
                        :enabled_modules,
                        :issue_statuses,
                        :issues,
                        :enumerations,
                        :custom_fields,
                        :custom_values,
                        :custom_fields_trackers,
                        :attachments
               # create an issue
               def test_add_issue
                 log_user('jsmith', 'jsmith')
                 get '/projects/ecookbook/issues/new'
                 assert_response :success
                 assert_template 'issues/new'
                 issue = new_record(Issue) do
                   post '/projects/ecookbook/issues',
                                              :issue => { :tracker_id => "1",
                                                          :start_date => "2006-12-26",
                                                          :priority_id => "4",
                                                          :subject => "new test issue",
                                                          :category_id => "",
                                                          :description => "new issue",
                                                          :done_ratio => "0",
                                                          :due_date => "",
                                                          :assigned_to_id => "" },
                                              :custom_fields => {'2' => 'Value for field 2'}
                 end
                 # check redirection
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => issue
                 follow_redirect!
                 assert_equal issue, assigns(:issue)
                 # check issue attributes
                 assert_equal 'jsmith', issue.author.login
                 assert_equal 1, issue.project.id
                 assert_equal 1, issue.status.id
               end
               def test_create_issue_by_anonymous_without_permission_should_fail
                 Role.anonymous.remove_permission! :add_issues
                 assert_no_difference 'Issue.count' do
                   post '/projects/1/issues', :tracker_id => "1", :issue => {:subject => "new test issue"}
                 end
                 assert_response 302
               end
               def test_create_issue_by_anonymous_with_custom_permission_should_succeed
                 Role.anonymous.remove_permission! :add_issues
                 Member.create!(:project_id => 1, :principal => Group.anonymous, :role_ids => [3])
                 issue = new_record(Issue) do
                   post '/projects/1/issues', :tracker_id => "1", :issue => {:subject => "new test issue"}
                   assert_response 302
                 end
                 assert_equal User.anonymous, issue.author
               end
               # add then remove 2 attachments to an issue
               def test_issue_attachments
                 log_user('jsmith', 'jsmith')
                 set_tmp_attachments_directory
                 attachment = new_record(Attachment) do
                   put '/issues/1',
                        :notes => 'Some notes',
                        :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'This is an attachment'}}
                   assert_redirected_to "/issues/1"
                 end
                 assert_equal Issue.find(1), attachment.container
                 assert_equal 'testfile.txt', attachment.filename
                 assert_equal 'This is an attachment', attachment.description
                 # verify the size of the attachment stored in db
                 #assert_equal file_data_1.length, attachment.filesize
                 # verify that the attachment was written to disk
                 assert File.exist?(attachment.diskfile)
                 # remove the attachments
                 Issue.find(1).attachments.each(&:destroy)
                 assert_equal 0, Issue.find(1).attachments.length
               end
               def test_other_formats_links_on_index
                 get '/projects/ecookbook/issues'
                 %w(Atom PDF CSV).each do |format|
                   assert_select 'a[rel=nofollow][href=?]', "/projects/ecookbook/issues.#{format.downcase}", :text => format
                 end
               end
               def test_other_formats_links_on_index_without_project_id_in_url
                 get '/issues', :project_id => 'ecookbook'
                 %w(Atom PDF CSV).each do |format|
                   assert_select 'a[rel=nofollow][href=?]', "/projects/ecookbook/issues.#{format.downcase}", :text => format
                 end
               end
               def test_pagination_links_on_index
                 with_settings :per_page_options => '2' do
                   get '/projects/ecookbook/issues'
                   assert_select 'a[href=?]', '/projects/ecookbook/issues?page=2', :text => '2'
                 end
               end
-              def test_pagination_links_on_index_without_project_id_in_url
+              def test_pagination_links_should_preserve_query_parameters
                 with_settings :per_page_options => '2' do
-                  get '/issues', :project_id => 'ecookbook'
+                  get '/projects/ecookbook/issues?foo=bar'
-                  assert_select 'a[href=?]', '/projects/ecookbook/issues?page=2', :text => '2'
+                  assert_select 'a[href=?]', '/projects/ecookbook/issues?foo=bar&page=2', :text => '2'
                 end
               end
               def test_issue_with_user_custom_field
                 @field = IssueCustomField.create!(:name => 'Tester', :field_format => 'user', :is_for_all => true, :trackers => Tracker.all)
                 Role.anonymous.add_permission! :add_issues, :edit_issues
                 users = Project.find(1).users.uniq.sort
                 tester = users.first
                 # Issue form
                 get '/projects/ecookbook/issues/new'
                 assert_response :success
                 assert_select 'select[name=?]', "issue[custom_field_values][#{@field.id}]" do
                   assert_select 'option', users.size + 1 # +1 for blank value
                   assert_select 'option[value=?]', tester.id.to_s, :text => tester.name
                 end
                 # Create issue
                 issue = new_record(Issue) do
                   post '/projects/ecookbook/issues',
                     :issue => {
                       :tracker_id => '1',
                       :priority_id => '4',
                       :subject => 'Issue with user custom field',
                       :custom_field_values => {@field.id.to_s => users.first.id.to_s}
                     }
                   assert_response 302
                 end
                 # Issue view
                 follow_redirect!
                 assert_select ".cf_#{@field.id}" do
                   assert_select '.label', :text => 'Tester:'
                   assert_select '.value', :text => tester.name
                 end
                 assert_select 'select[name=?]', "issue[custom_field_values][#{@field.id}]" do
                   assert_select 'option', users.size + 1 # +1 for blank value
                   assert_select 'option[value=?][selected=selected]', tester.id.to_s, :text => tester.name
                 end
                 new_tester = users[1]
                 with_settings :default_language => 'en' do
                   # Update issue
                   assert_difference 'Journal.count' do
                     put "/issues/#{issue.id}",
                         :notes => 'Updating custom field',
                         :issue => {
                             :custom_field_values => {@field.id.to_s => new_tester.id.to_s}
                           }
                     assert_redirected_to "/issues/#{issue.id}"
                   end
                   # Issue view
                   follow_redirect!
                   assert_select 'ul.details li', :text => "Tester changed from #{tester} to #{new_tester}"
                 end
               end
               def test_update_using_invalid_http_verbs
                 subject = 'Updated by an invalid http verb'
                 get '/issues/update/1', {:issue => {:subject => subject}}, credentials('jsmith')
                 assert_response 404
                 assert_not_equal subject, Issue.find(1).subject
                 post '/issues/1', {:issue => {:subject => subject}}, credentials('jsmith')
                 assert_response 404
                 assert_not_equal subject, Issue.find(1).subject
               end
               def test_get_watch_should_be_invalid
                 assert_no_difference 'Watcher.count' do
                   get '/watchers/watch?object_type=issue&object_id=1', {}, credentials('jsmith')
                   assert_response 404
                 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