jro_apps/redmine Commit - r13406:93690ee83032

Send the content type as parameter when uploading a file....

Jean-Philippe Lang -

r13406:93690ee83032

parent child

Context file:

r13406:93690ee83032

Collapse all files

app/controllers/attachments_controller.rb +1 0

             # Redmine - project management software
             # Copyright (C) 2006-2014  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 AttachmentsController < ApplicationController
               before_filter :find_attachment, :only => [:show, :download, :thumbnail, :destroy]
               before_filter :find_editable_attachments, :only => [:edit, :update]
               before_filter :file_readable, :read_authorize, :only => [:show, :download, :thumbnail]
               before_filter :delete_authorize, :only => :destroy
               before_filter :authorize_global, :only => :upload
               accept_api_auth :show, :download, :upload
               def show
                 respond_to do |format|
                   format.html {
                     if @attachment.is_diff?
                       @diff = File.new(@attachment.diskfile, "rb").read
                       @diff_type = params[:type] || User.current.pref[:diff_type] || 'inline'
                       @diff_type = 'inline' unless %w(inline sbs).include?(@diff_type)
                       # Save diff type as user preference
                       if User.current.logged? && @diff_type != User.current.pref[:diff_type]
                         User.current.pref[:diff_type] = @diff_type
                         User.current.preference.save
                       end
                       render :action => 'diff'
                     elsif @attachment.is_text? && @attachment.filesize <= Setting.file_max_size_displayed.to_i.kilobyte
                       @content = File.new(@attachment.diskfile, "rb").read
                       render :action => 'file'
                     else
                       download
                     end
                   }
                   format.api
                 end
               end
               def download
                 if @attachment.container.is_a?(Version) || @attachment.container.is_a?(Project)
                   @attachment.increment_download
                 end
                 if stale?(:etag => @attachment.digest)
                   # images are sent inline
                   send_file @attachment.diskfile, :filename => filename_for_content_disposition(@attachment.filename),
                                                   :type => detect_content_type(@attachment),
                                                   :disposition => (@attachment.image? ? 'inline' : 'attachment')
                 end
               end
               def thumbnail
                 if @attachment.thumbnailable? && tbnail = @attachment.thumbnail(:size => params[:size])
                   if stale?(:etag => tbnail)
                     send_file tbnail,
                       :filename => filename_for_content_disposition(@attachment.filename),
                       :type => detect_content_type(@attachment),
                       :disposition => 'inline'
                   end
                 else
                   # No thumbnail for the attachment or thumbnail could not be created
                   render :nothing => true, :status => 404
                 end
               end
               def upload
                 # Make sure that API users get used to set this content type
                 # as it won't trigger Rails' automatic parsing of the request body for parameters
                 unless request.content_type == 'application/octet-stream'
                   render :nothing => true, :status => 406
                   return
                 end
                 @attachment = Attachment.new(:file => request.raw_post)
                 @attachment.author = User.current
                 @attachment.filename = params[:filename].presence || Redmine::Utils.random_hex(16)
+                @attachment.content_type = params[:content_type].presence
                 saved = @attachment.save
                 respond_to do |format|
                   format.js
                   format.api {
                     if saved
                       render :action => 'upload', :status => :created
                     else
                       render_validation_errors(@attachment)
                     end
                   }
                 end
               end
               def edit
               end
               def update
                 if params[:attachments].is_a?(Hash)
                   if Attachment.update_attachments(@attachments, params[:attachments])
                     redirect_back_or_default home_path
                     return
                   end
                 end
                 render :action => 'edit'
               end
               def destroy
                 if @attachment.container.respond_to?(:init_journal)
                   @attachment.container.init_journal(User.current)
                 end
                 if @attachment.container
                   # Make sure association callbacks are called
                   @attachment.container.attachments.delete(@attachment)
                 else
                   @attachment.destroy
                 end
                 respond_to do |format|
                   format.html { redirect_to_referer_or project_path(@project) }
                   format.js
                 end
               end
               private
               def find_attachment
                 @attachment = Attachment.find(params[:id])
                 # Show 404 if the filename in the url is wrong
                 raise ActiveRecord::RecordNotFound if params[:filename] && params[:filename] != @attachment.filename
                 @project = @attachment.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_editable_attachments
                 klass = params[:object_type].to_s.singularize.classify.constantize rescue nil
                 unless klass && klass.reflect_on_association(:attachments)
                   render_404
                   return
                 end
                 @container = klass.find(params[:object_id])
                 if @container.respond_to?(:visible?) && !@container.visible?
                   render_403
                   return
                 end
                 @attachments = @container.attachments.select(&:editable?)
                 if @container.respond_to?(:project)
                   @project = @container.project
                 end
                 render_404 if @attachments.empty?
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Checks that the file exists and is readable
               def file_readable
                 if @attachment.readable?
                   true
                 else
                   logger.error "Cannot send attachment, #{@attachment.diskfile} does not exist or is unreadable."
                   render_404
                 end
               end
               def read_authorize
                 @attachment.visible? ? true : deny_access
               end
               def delete_authorize
                 @attachment.deletable? ? true : deny_access
               end
               def detect_content_type(attachment)
                 content_type = attachment.content_type
                 if content_type.blank?
                   content_type = Redmine::MimeType.of(attachment.filename)
                 end
                 content_type.to_s
               end
             end

public/javascripts/attachments.js +1 0

             /* Redmine - project management software
                Copyright (C) 2006-2014  Jean-Philippe Lang */
             function addFile(inputEl, file, eagerUpload) {
               if ($('#attachments_fields').children().length < 10) {
                 var attachmentId = addFile.nextAttachmentId++;
                 var fileSpan = $('<span>', { id: 'attachments_' + attachmentId });
                 fileSpan.append(
                     $('<input>', { type: 'text', 'class': 'filename readonly', name: 'attachments[' + attachmentId + '][filename]', readonly: 'readonly'} ).val(file.name),
                     $('<input>', { type: 'text', 'class': 'description', name: 'attachments[' + attachmentId + '][description]', maxlength: 255, placeholder: $(inputEl).data('description-placeholder') } ).toggle(!eagerUpload),
                     $('<a>&nbsp</a>').attr({ href: "#", 'class': 'remove-upload' }).click(removeFile).toggle(!eagerUpload)
                 ).appendTo('#attachments_fields');
                 if(eagerUpload) {
                   ajaxUpload(file, attachmentId, fileSpan, inputEl);
                 }
                 return attachmentId;
               }
               return null;
             }
             addFile.nextAttachmentId = 1;
             function ajaxUpload(file, attachmentId, fileSpan, inputEl) {
               function onLoadstart(e) {
                 fileSpan.removeClass('ajax-waiting');
                 fileSpan.addClass('ajax-loading');
                 $('input:submit', $(this).parents('form')).attr('disabled', 'disabled');
               }
               function onProgress(e) {
                 if(e.lengthComputable) {
                   this.progressbar( 'value', e.loaded * 100 / e.total );
                 }
               }
               function actualUpload(file, attachmentId, fileSpan, inputEl) {
                 ajaxUpload.uploading++;
                 uploadBlob(file, $(inputEl).data('upload-path'), attachmentId, {
                     loadstartEventHandler: onLoadstart.bind(progressSpan),
                     progressEventHandler: onProgress.bind(progressSpan)
                   })
                   .done(function(result) {
                     progressSpan.progressbar( 'value', 100 ).remove();
                     fileSpan.find('input.description, a').css('display', 'inline-block');
                   })
                   .fail(function(result) {
                     progressSpan.text(result.statusText);
                   }).always(function() {
                     ajaxUpload.uploading--;
                     fileSpan.removeClass('ajax-loading');
                     var form = fileSpan.parents('form');
                     if (form.queue('upload').length == 0 && ajaxUpload.uploading == 0) {
                       $('input:submit', form).removeAttr('disabled');
                     }
                     form.dequeue('upload');
                   });
               }
               var progressSpan = $('<div>').insertAfter(fileSpan.find('input.filename'));
               progressSpan.progressbar();
               fileSpan.addClass('ajax-waiting');
               var maxSyncUpload = $(inputEl).data('max-concurrent-uploads');
               if(maxSyncUpload == null || maxSyncUpload <= 0 || ajaxUpload.uploading < maxSyncUpload)
                 actualUpload(file, attachmentId, fileSpan, inputEl);
               else
                 $(inputEl).parents('form').queue('upload', actualUpload.bind(this, file, attachmentId, fileSpan, inputEl));
             }
             ajaxUpload.uploading = 0;
             function removeFile() {
               $(this).parent('span').remove();
               return false;
             }
             function uploadBlob(blob, uploadUrl, attachmentId, options) {
               var actualOptions = $.extend({
                 loadstartEventHandler: $.noop,
                 progressEventHandler: $.noop
               }, options);
               uploadUrl = uploadUrl + '?attachment_id=' + attachmentId;
               if (blob instanceof window.File) {
                 uploadUrl += '&filename=' + encodeURIComponent(blob.name);
+                uploadUrl += '&content_type=' + encodeURIComponent(blob.type);
               }
               return $.ajax(uploadUrl, {
                 type: 'POST',
                 contentType: 'application/octet-stream',
                 beforeSend: function(jqXhr, settings) {
                   jqXhr.setRequestHeader('Accept', 'application/js');
                   // attach proper File object
                   settings.data = blob;
                 },
                 xhr: function() {
                   var xhr = $.ajaxSettings.xhr();
                   xhr.upload.onloadstart = actualOptions.loadstartEventHandler;
                   xhr.upload.onprogress = actualOptions.progressEventHandler;
                   return xhr;
                 },
                 data: blob,
                 cache: false,
                 processData: false
               });
             }
             function addInputFiles(inputEl) {
               var clearedFileInput = $(inputEl).clone().val('');
               if ($.ajaxSettings.xhr().upload && inputEl.files) {
                 // upload files using ajax
                 uploadAndAttachFiles(inputEl.files, inputEl);
                 $(inputEl).remove();
               } else {
                 // browser not supporting the file API, upload on form submission
                 var attachmentId;
                 var aFilename = inputEl.value.split(/\/|\\/);
                 attachmentId = addFile(inputEl, { name: aFilename[ aFilename.length - 1 ] }, false);
                 if (attachmentId) {
                   $(inputEl).attr({ name: 'attachments[' + attachmentId + '][file]', style: 'display:none;' }).appendTo('#attachments_' + attachmentId);
                 }
               }
               clearedFileInput.insertAfter('#attachments_fields');
             }
             function uploadAndAttachFiles(files, inputEl) {
               var maxFileSize = $(inputEl).data('max-file-size');
               var maxFileSizeExceeded = $(inputEl).data('max-file-size-message');
               var sizeExceeded = false;
               $.each(files, function() {
                 if (this.size && maxFileSize != null && this.size > parseInt(maxFileSize)) {sizeExceeded=true;}
               });
               if (sizeExceeded) {
                 window.alert(maxFileSizeExceeded);
               } else {
                 $.each(files, function() {addFile(inputEl, this, true);});
               }
             }
             function handleFileDropEvent(e) {
               $(this).removeClass('fileover');
               blockEventPropagation(e);
               if ($.inArray('Files', e.dataTransfer.types) > -1) {
                 uploadAndAttachFiles(e.dataTransfer.files, $('input:file.file_selector'));
               }
             }
             function dragOverHandler(e) {
               $(this).addClass('fileover');
               blockEventPropagation(e);
             }
             function dragOutHandler(e) {
               $(this).removeClass('fileover');
               blockEventPropagation(e);
             }
             function setupFileDrop() {
               if (window.File && window.FileList && window.ProgressEvent && window.FormData) {
                 $.event.fixHooks.drop = { props: [ 'dataTransfer' ] };
                 $('form div.box').has('input:file').each(function() {
                   $(this).on({
                       dragover: dragOverHandler,
                       dragleave: dragOutHandler,
                       drop: handleFileDropEvent
                   });
                 });
               }
             }
             $(document).ready(setupFileDrop);

test/integration/attachments_test.rb +10 0

             # Redmine - project management software
             # Copyright (C) 2006-2014  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 AttachmentsTest < Redmine::IntegrationTest
               fixtures :projects, :enabled_modules,
                        :users, :roles, :members, :member_roles,
                        :trackers, :projects_trackers,
                        :issue_statuses, :enumerations
               def test_upload_should_set_default_content_type
                 log_user('jsmith', 'jsmith')
                 assert_difference 'Attachment.count' do
                   post "/uploads.js?attachment_id=1&filename=foo.txt", "File content", {"CONTENT_TYPE" => 'application/octet-stream'}
                   assert_response :success
                 end
                 attachment = Attachment.order(:id => :desc).first
                 assert_equal 'text/plain', attachment.content_type
               end
+              def test_upload_should_accept_content_type_param
+                log_user('jsmith', 'jsmith')
+                assert_difference 'Attachment.count' do
+                  post "/uploads.js?attachment_id=1&filename=foo&content_type=image/jpeg", "File content", {"CONTENT_TYPE" => 'application/octet-stream'}
+                  assert_response :success
+                end
+                attachment = Attachment.order(:id => :desc).first
+                assert_equal 'image/jpeg', attachment.content_type
+              end
               def test_upload_as_js_and_attach_to_an_issue
                 log_user('jsmith', 'jsmith')
                 token = ajax_upload('myupload.txt', 'File content')
                 assert_difference 'Issue.count' do
                   post '/projects/ecookbook/issues', {
                       :issue => {:tracker_id => 1, :subject => 'Issue with upload'},
                       :attachments => {'1' => {:filename => 'myupload.txt', :description => 'My uploaded file', :token => token}}
                     }
                   assert_response 302
                 end
                 issue = Issue.order('id DESC').first
                 assert_equal 'Issue with upload', issue.subject
                 assert_equal 1, issue.attachments.count
                 attachment = issue.attachments.first
                 assert_equal 'myupload.txt', attachment.filename
                 assert_equal 'My uploaded file', attachment.description
                 assert_equal 'File content'.length, attachment.filesize
               end
               def test_upload_as_js_and_preview_as_inline_attachment
                 log_user('jsmith', 'jsmith')
                 token = ajax_upload('myupload.jpg', 'JPEG content')
                 post '/issues/preview/new/ecookbook', {
                     :issue => {:tracker_id => 1, :description => 'Inline upload: !myupload.jpg!'},
                     :attachments => {'1' => {:filename => 'myupload.jpg', :description => 'My uploaded file', :token => token}}
                   }
                 assert_response :success
                 attachment_path = response.body.match(%r{<img src="(/attachments/download/\d+/myupload.jpg)"})[1]
                 assert_not_nil token, "No attachment path found in response:\n#{response.body}"
                 get attachment_path
                 assert_response :success
                 assert_equal 'JPEG content', response.body
               end
               def test_upload_and_resubmit_after_validation_failure
                 log_user('jsmith', 'jsmith')
                 token = ajax_upload('myupload.txt', 'File content')
                 assert_no_difference 'Issue.count' do
                   post '/projects/ecookbook/issues', {
                       :issue => {:tracker_id => 1, :subject => ''},
                       :attachments => {'1' => {:filename => 'myupload.txt', :description => 'My uploaded file', :token => token}}
                     }
                   assert_response :success
                 end
                 assert_select 'input[type=hidden][name=?][value=?]', 'attachments[p0][token]', token
                 assert_select 'input[name=?][value=?]', 'attachments[p0][filename]', 'myupload.txt'
                 assert_select 'input[name=?][value=?]', 'attachments[p0][description]', 'My uploaded file'
                 assert_difference 'Issue.count' do
                   post '/projects/ecookbook/issues', {
                       :issue => {:tracker_id => 1, :subject => 'Issue with upload'},
                       :attachments => {'p0' => {:filename => 'myupload.txt', :description => 'My uploaded file', :token => token}}
                     }
                   assert_response 302
                 end
                 issue = Issue.order('id DESC').first
                 assert_equal 'Issue with upload', issue.subject
                 assert_equal 1, issue.attachments.count
                 attachment = issue.attachments.first
                 assert_equal 'myupload.txt', attachment.filename
                 assert_equal 'My uploaded file', attachment.description
                 assert_equal 'File content'.length, attachment.filesize
               end
               def test_upload_as_js_and_destroy
                 log_user('jsmith', 'jsmith')
                 token = ajax_upload('myupload.txt', 'File content')
                 attachment = Attachment.order('id DESC').first
                 attachment_path = "/attachments/#{attachment.id}.js?attachment_id=1"
                 assert_include "href: '#{attachment_path}'", response.body, "Path to attachment: #{attachment_path} not found in response:\n#{response.body}"
                 assert_difference 'Attachment.count', -1 do
                   delete attachment_path
                   assert_response :success
                 end
                 assert_include "$('#attachments_1').remove();", response.body
               end
               private
               def ajax_upload(filename, content, attachment_id=1)
                 assert_difference 'Attachment.count' do
                   post "/uploads.js?attachment_id=#{attachment_id}&filename=#{filename}", content, {"CONTENT_TYPE" => 'application/octet-stream'}
                   assert_response :success
                   assert_equal 'text/javascript', response.content_type
                 end
                 token = response.body.match(/\.val\('(\d+\.[0-9a-f]+)'\)/)[1]
                 assert_not_nil token, "No upload token found in response:\n#{response.body}"
                 token
               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