Redmine

gem 'rubyzip', (RUBY_VERSION < '2.4' ? '~> 1.3.0' : '~> 2.2.0')

  before_action :find_container, :only => [:edit_all, :update_all, :download_all]

  before_action :find_downloadable_attachments, :only => :download_all

  def download_all

    Tempfile.create('attachments_zip', Rails.root.join('tmp')) do |tempfile|

      zip_file = Attachment.attachments_to_zip(tempfile, @attachments)

      if zip_file

        send_data(

          File.read(zip_file.path),

          :type => 'application/zip',

          :filename => "#{@container.class.to_s.downcase}-#{@container.id}-attachments.zip")

      else

        render_404

      end

    end

  end

    @attachments = @container.attachments.select(&:editable?)

    render_404 if @attachments.empty?

  end

  def find_container

  def find_downloadable_attachments

    @attachments = @container.attachments.select{|a| File.readable?(a.diskfile) }

    bulk_download_max_size = Setting.bulk_download_max_size.to_i.kilobytes

    if @attachments.sum(&:filesize) > bulk_download_max_size

      flash[:error] = l(:error_bulk_download_size_too_big,

                        :max_size => bulk_download_max_size.to_i.kilobytes)

      redirect_to back_url

      return

    end

  end

  def container_attachments_download_path(container)

    object_attachments_download_path container.class.name.underscore.pluralize, container.id

  end

require "zip"

  def self.attachments_to_zip(tmpfile, attachments)

    attachments = attachments.select{|attachment| File.readable?(attachment.diskfile) }

    return nil if attachments.blank?

    Zip.unicode_names = true

    existing_file_names = []

    Zip::File.open(tmpfile.path, Zip::File::CREATE) do |zip|

      attachments.each do |attachment|

        filename = attachment.filename

        existing_file_names << filename

        # If a file with the same name already exists, change the file name.

        if existing_file_names.count(filename) > 1

          filename = "#{File.basename(filename, '.*')}(#{existing_file_names.count(filename)})#{File.extname(filename)}"

        end

        zip.add(filename, attachment.diskfile)

      end

    end

    tmpfile

  end

<% if attachments.size > 1 %>

<div class="bulk-download">

  <%= link_to(l(:label_download_all_attachments),

  container_attachments_download_path(container),

  :title => l(:label_download_all_attachments),

  :class => 'icon icon-download'

  ) %>

</div>

<% end %>

<p><%= setting_text_field :bulk_download_max_size, :size => 6 %> <%= l(:"number.human.storage_units.units.kb") %></p>

  error_bulk_download_size_too_big: "These attachments cannot be bulk downloaded because the total file size exceeds the maximum allowed size (%{max_size})"

  setting_bulk_download_max_size: Maximum total size for bulk download

  label_download_all_attachments: Download all attached files

  get 'attachments/:object_type/:object_id/download', :to => 'attachments#download_all', :as => :object_attachments_download

bulk_download_max_size:

  format: int

  default: 512000

div.bulk-download { margin-top: 1em; margin-left: 0.3em; margin-bottom: 0.4em;}

  def test_download_all_with_valid_container

    @request.session[:user_id] = 2

    get :download_all, :params => {

        :object_type => 'issues',

        :object_id => '2'

      }

    assert_response 200

    assert_equal response.headers['Content-Type'], 'application/zip'

    assert_match /issue-2-attachments.zip/, response.headers['Content-Disposition']

    assert_not_includes Dir.entries(Rails.root.join('tmp')), /attachments_zip/

  end

  def test_download_all_with_invalid_container

    @request.session[:user_id] = 2

    get :download_all, :params => {

        :object_type => 'issues',

        :object_id => '999'

      }

    assert_response 404

  end

  def test_download_all_without_readable_attachments

    @request.session[:user_id] = 2

    get :download_all, :params => {

        :object_type => 'issues',

        :object_id => '1'

      }

    assert_equal Issue.find(1).attachments, []

    assert_response 404

  end

  def test_download_all_with_maximum_bulk_download_size_larger_than_attachments

    with_settings :bulk_download_max_size => 0 do

      @request.session[:user_id] = 2

      get :download_all, :params => {

          :object_type => 'issues',

          :object_id => '2',

          :back_url => '/issues/2'

      }

      assert_redirected_to '/issues/2'

      assert_equal flash[:error], 'These attachments cannot be bulk downloaded because the total file size exceeds the maximum allowed size (0)'

    end

  end

  def test_attachments_to_zip_with_attachments

    attachment = Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1)

    Tempfile.create('attachments_zip', Rails.root.join('tmp')) do |tempfile|

      zip_file = Attachment.attachments_to_zip(tempfile, [attachment])

      assert_instance_of File, zip_file

    end

  end

  def test_attachments_to_zip_without_attachments

    Tempfile.create('attachments_zip', Rails.root.join('tmp')) do |tempfile|

      zip_file = Attachment.attachments_to_zip(tempfile, [])

      assert_nil zip_file

    end

  end

  def test_attachments_to_zip_should_not_duplicate_file_names

    attachment1 = Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1)

    attachment2 = Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1)

    Tempfile.create('attachments_zip', Rails.root.join('tmp')) do |tempfile|

      zip_file = Attachment.attachments_to_zip(tempfile, [attachment1, attachment2])

      zip_file_names = ['testfile.txt', 'testfile(2).txt']

      Zip::File.open(zip_file.path) do |z|

        z.each_with_index do |entry, i|

          assert_includes zip_file_names[i], entry.name

        end

      end

    end

  end