Redmine

gem "rubyzip", "~> 2.0.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.nil?

        render_404

        return

      end

      send_data(File.read(zip_file.path), :type => 'application/zip',

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

    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 = Redmine::Configuration['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)

      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

  <%= link_to(l(:label_download_attachments),

              container_attachments_download_path(container),

              :title => l(:label_download_attachments),

              :class => 'icon-only icon-download'

             ) %>

  # Configre maximum size of zip file(KB)

  # bulk_download_max_size: 51200

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

  label_download_attachments: Download attached files

  error_bulk_download_size_too_big: これらの添付ファイルをダウンロードできません。一括ダウンロードサイズの上限(%{max_size})を超えています。

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

      'max_concurrent_ajax_uploads' => 2,

      'bulk_download_max_size' => 51200

  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

    Redmine::Configuration.with '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 download because it exceeds the maximum allowed bulk download 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

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

    attachment_2 = 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_1, attachment_2])

      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