Redmine

    when 'Attachment'

      html ? link_to_attachment(object, :download => true) : object.filename

    no_details = false

        if custom_field.format.class.change_no_details

          no_details = true

        elsif custom_field.format.class.change_as_diff

    if no_details

      s = l(:text_journal_changed_no_detail, :label => label).html_safe

    elsif show_diff

  def set_custom_field_value(custom_field_value, value)

    format.set_custom_field_value(self, custom_field_value, value)

  end

    errs = format.validate_custom_value(custom_value)

    unless errs.any?

      if value.is_a?(Array)

        if !multiple?

          errs << ::I18n.t('activerecord.errors.messages.invalid')

        end

        if is_required? && value.detect(&:present?).nil?

          errs << ::I18n.t('activerecord.errors.messages.blank')

        end

      else

        if is_required? && value.blank?

          errs << ::I18n.t('activerecord.errors.messages.blank')

        end

  def after_save_custom_value(custom_value)

    format.after_save_custom_value(self, custom_value)

  end

  def value=(v)

    @value = custom_field.set_custom_field_value(self, v)

  end

  after_save :custom_field_after_save_custom_value

  def attachments_visible?(user)

    visible? && customized && customized.visible?(user)

  end

  private

  def custom_field_after_save_custom_value

    custom_field.after_save_custom_value(self)

  end

<% attachment_param ||= 'attachments' %>

<% saved_attachments ||= container.saved_attachments if defined?(container) && container %>

<% multiple = true unless defined?(multiple) && multiple == false %>

<% show_add = multiple || saved_attachments.blank? %>

<% description = (defined?(description) && description == false ? false : true) %>

<% css_class = (defined?(filedrop) && filedrop == false ? '' : 'filedrop') %>

<span class="attachments_form">

  <span class="attachments_fields">

  <% if saved_attachments.present? %>

    <% saved_attachments.each_with_index do |attachment, i| %>

      <span id="attachments_p<%= i %>">

        <%= text_field_tag("#{attachment_param}[p#{i}][filename]", attachment.filename, :class => 'filename') %>

        <% if attachment.container_id.present? %>

          <%= link_to l(:label_delete), "#", :onclick => "$(this).closest('.attachments_form').find('.add_attachment').show(); $(this).parent().remove(); return false;", :class => 'icon-only icon-del' %>

          <%= hidden_field_tag "#{attachment_param}[p#{i}][id]", attachment.id %>

        <% else %>

          <%= text_field_tag("#{attachment_param}[p#{i}][description]", attachment.description, :maxlength => 255, :placeholder => l(:label_optional_description), :class => 'description') if description %>

          <%= link_to('&nbsp;'.html_safe, attachment_path(attachment, :attachment_id => "p#{i}", :format => 'js'), :method => 'delete', :remote => true, :class => 'remove-upload') %>

          <%= hidden_field_tag "#{attachment_param}[p#{i}][token]", attachment.token %>

        <% end %>

      </span>

    <% end %>

  </span>

  <span class="add_attachment" style="<%= show_add ? nil : 'display:none;' %>">

    <%= file_field_tag "#{attachment_param}[dummy][file]",

        :id => nil,

        :class => "file_selector #{css_class}",

        :multiple => multiple,

        :onchange => 'addInputFiles(this);',

        :data => {

          :max_file_size => Setting.attachment_max_size.to_i.kilobytes,

          :max_file_size_message => l(:error_attachment_too_big, :max_size => number_to_human_size(Setting.attachment_max_size.to_i.kilobytes)),

          :max_concurrent_uploads => Redmine::Configuration['max_concurrent_ajax_uploads'].to_i,

          :upload_path => uploads_path(:format => 'js'),

          :param => attachment_param,

          :description => description,

          :description_placeholder => l(:label_optional_description)

        } %>

    (<%= l(:label_max_size) %>: <%= number_to_human_size(Setting.attachment_max_size.to_i.kilobytes) %>)

  </span>

$('#attachments_<%= j params[:attachment_id] %>').closest('.attachments_form').find('.add_attachment').show();

fileSpan.find('input.token').val('<%= j @attachment.token %>');

    <% if @custom_field.format.is_filter_supported %>

    <% end %>

    <% if @custom_field.format.is_filter_supported %>

    <% end %>

    <% if @custom_field.format.is_filter_supported %>

    <% end %>

    <% if @custom_field.format.is_filter_supported %>

    <% end %>

    <% if @custom_field.format.is_filter_supported %>

    <% end %>

    <% if @custom_field.format.is_filter_supported %>

    <% end %>

          after_rollback :detach_saved_attachments

              elsif token = attachment['token'].presence

        def detach_saved_attachments

          saved_attachments.each do |attachment|

            # TODO: use #reload instead, after upgrading to Rails 5

            # (after_rollback is called when running transactional tests in Rails 4)

            attachment.container = nil

          end

        end

              custom_field_value.value = values[key]

              x.instance_variable_set("@value", values.map(&:value))

              x.instance_variable_set("@value", cv.value)

      # Set this to true if the format supports filtering on custom values

      class_attribute :is_filter_supported

      self.is_filter_supported = true

      class_attribute :change_no_details

      self.change_no_details = false

      def set_custom_field_value(custom_field, custom_field_value, value)

        if value.is_a?(Array)

          value = value.map(&:to_s).reject{|v| v==''}.uniq

          if value.empty?

            value << ''

          end

        else

          value = value.to_s

        end

        value

      end

      # custom_value is a CustomFieldValue.

      # CustomValue after_save callback

      def after_save_custom_value(custom_field, custom_value)

      end

    class AttachementFormat < Base

      add 'attachment'

      self.form_partial = 'custom_fields/formats/attachment'

      self.is_filter_supported = false

      self.change_no_details = true

      def set_custom_field_value(custom_field, custom_field_value, value)

        attachment_present = false

        if value.is_a?(Hash)

          attachment_present = true

          value = value.except(:blank)

          if value.values.any? && value.values.all? {|v| v.is_a?(Hash)}

            value = value.values.first

          end

          if value.key?(:id)

            value = set_custom_field_value_by_id(custom_field, custom_field_value, value[:id])

          elsif value[:token].present?

            if attachment = Attachment.find_by_token(value[:token])

              value = attachment.id.to_s

            else

              value = ''

            end

          elsif value.key?(:file)

            attachment = Attachment.new(:file => value[:file], :author => User.current)

            if attachment.save

              value = attachment.id.to_s

            else

              value = ''

            end

          else

            attachment_present = false

            value = ''

          end

        elsif value.is_a?(String)

          value = set_custom_field_value_by_id(custom_field, custom_field_value, value)

        end

        custom_field_value.instance_variable_set "@attachment_present", attachment_present

        value

      end

      def set_custom_field_value_by_id(custom_field, custom_field_value, id)

        attachment = Attachment.find_by_id(id)

        if attachment && attachment.container.is_a?(CustomValue) && attachment.container.customized == custom_field_value.customized

          id.to_s

        else

          ''

        end

      end

      private :set_custom_field_value_by_id

      def cast_single_value(custom_field, value, customized=nil)

        Attachment.find_by_id(value.to_i) if value.present? && value.respond_to?(:to_i)

      end

      def validate_custom_value(custom_value)

        errors = []

        if custom_value.instance_variable_get("@attachment_present") && custom_value.value.blank?

          errors << ::I18n.t('activerecord.errors.messages.invalid')

        end

        errors.uniq

      end

      def after_save_custom_value(custom_field, custom_value)

        if custom_value.value_changed?

          if custom_value.value.present?

            attachment = Attachment.where(:id => custom_value.value.to_s).first

            if attachment

              attachment.container = custom_value

              attachment.save!

            end

          end

          if custom_value.value_was.present?

            attachment = Attachment.where(:id => custom_value.value_was.to_s).first

            if attachment

              attachment.destroy

            end

          end

        end

      end

      def edit_tag(view, tag_id, tag_name, custom_value, options={})

        attachment = nil

        if custom_value.value.present? #&& custom_value.value == custom_value.value_was

          attachment = Attachment.find_by_id(custom_value.value)

        end

        view.hidden_field_tag("#{tag_name}[blank]", "") +

          view.render(:partial => 'attachments/form',

            :locals => {

              :attachment_param => tag_name,

              :multiple => false,

              :description => false,

              :saved_attachments => [attachment].compact,

              :filedrop => false

            })

      end

    end

  var attachmentsFields = $(inputEl).closest('.attachments_form').find('.attachments_fields');

  var addAttachment = $(inputEl).closest('.attachments_form').find('.add_attachment');

  var maxFiles = ($(inputEl).prop('multiple') == true ? 10 : 1);

  if (attachmentsFields.children().length < maxFiles) {

    var param = $(inputEl).data('param');

    if (!param) {param = 'attachments'};

        $('<input>', { type: 'text', 'class': 'filename readonly', name: param +'[' + attachmentId + '][filename]', readonly: 'readonly'} ).val(file.name),

        $('<input>', { type: 'text', 'class': 'description', name: param + '[' + attachmentId + '][description]', maxlength: 255, placeholder: $(inputEl).data('description-placeholder') } ).toggle(!eagerUpload),

        $('<input>', { type: 'hidden', 'class': 'token', name: param + '[' + attachmentId + '][token]'} ),

    ).appendTo(attachmentsFields);

    if ($(inputEl).data('description') == 0) {

      fileSpan.find('input.description').remove();

    }

    addAttachment.toggle(attachmentsFields.children().length < maxFiles);

  var attachmentsFields = $(inputEl).closest('.attachments_form').find('.attachments_fields');

  var addAttachment = $(inputEl).closest('.attachments_form').find('.add_attachment');

  var sizeExceeded = false;

  var param = $(inputEl).data('param');

  if (!param) {param = 'attachments'};

    sizeExceeded = uploadAndAttachFiles(inputEl.files, inputEl);

      $(inputEl).attr({ name: param + '[' + attachmentId + '][file]', style: 'display:none;' }).appendTo('#attachments_' + attachmentId);

  clearedFileInput.prependTo(addAttachment);

  return sizeExceeded;

    uploadAndAttachFiles(e.dataTransfer.files, $('input:file.filedrop').first());

    $('form div.box:not(.filedroplistner)').has('input:file.filedrop').each(function() {

      }).addClass('filedroplistner');

  line-height: 2em;

label.block {

  display: block;

  width: auto !important;

}

.attachments_fields input.description, #existing-attachments input.description {margin-left:4px; width:340px;}

.attachments_fields>span, #existing-attachments>span {display:block; white-space:nowrap;}

.attachments_fields input.filename, #existing-attachments .filename {border:0; width:250px; color:#555; background-color:inherit; background:url(../images/attachment.png) no-repeat 1px 50%; padding-left:18px;}

.tabular input.filename {max-width:75% !important;}

.attachments_fields input.filename {height:1.8em;}

.attachments_fields .ajax-waiting input.filename {background:url(../images/hourglass.png) no-repeat 0px 50%;}

.attachments_fields .ajax-loading input.filename {background:url(../images/loading.gif) no-repeat 0px 50%;}

.attachments_fields div.ui-progressbar { width: 100px; height:14px; margin: 2px 0 -5px 8px; display: inline-block; }

  vertical-align: middle;

# 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 AttachmentFieldFormatTest < 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

  def setup

    set_tmp_attachments_directory

    @field = IssueCustomField.generate!(:name => "File", :field_format => "attachment")

    log_user "jsmith", "jsmith"

  end

  def test_new_should_include_inputs

    get '/projects/ecookbook/issues/new'

    assert_response :success

    assert_select '[name^=?]', "issue[custom_field_values][#{@field.id}]", 2

    assert_select 'input[name=?][type=hidden][value=""]', "issue[custom_field_values][#{@field.id}][blank]"

  end

  def test_create_with_attachment

    issue = new_record(Issue) do

      assert_difference 'Attachment.count' do

        post '/projects/ecookbook/issues', {

            :issue => {

              :subject => "Subject",

              :custom_field_values => {

                @field.id => {

                  'blank' => '',

                  '1' => {:file => uploaded_test_file("testfile.txt", "text/plain")}

                }

              }

            }

          }

        assert_response 302

      end

    end

    custom_value = issue.custom_value_for(@field)

    assert custom_value

    assert custom_value.value.present?

    attachment = Attachment.find_by_id(custom_value.value)

    assert attachment

    assert_equal custom_value, attachment.container

    follow_redirect!

    assert_response :success

    # link to the attachment

    link = css_select(".cf_#{@field.id} .value a")

    assert_equal 1, link.size

    assert_equal "testfile.txt", link.text

    # download the attachment

    get link.attr('href')

    assert_response :success

    assert_equal "text/plain", response.content_type

  end

  def test_create_without_attachment

    issue = new_record(Issue) do

      assert_no_difference 'Attachment.count' do

        post '/projects/ecookbook/issues', {

            :issue => {

              :subject => "Subject",

              :custom_field_values => {

                @field.id => {:blank => ''}

              }

            }

          }

        assert_response 302

      end

    end

    custom_value = issue.custom_value_for(@field)

    assert custom_value

    assert custom_value.value.blank?

    follow_redirect!

    assert_response :success

    # no links to the attachment

    assert_select ".cf_#{@field.id} .value a", 0

  end

  def test_failure_on_create_should_preserve_attachment

    attachment = new_record(Attachment) do

      assert_no_difference 'Issue.count' do

        post '/projects/ecookbook/issues', {

            :issue => {

              :subject => "",

              :custom_field_values => {

                @field.id => {:file => uploaded_test_file("testfile.txt", "text/plain")}

              }

            }

          }

        assert_response :success

        assert_select_error /Subject cannot be blank/

      end

    end

    assert_nil attachment.container_id

    assert_select 'input[name=?][value=?][type=hidden]', "issue[custom_field_values][#{@field.id}][p0][token]", attachment.token

    assert_select 'input[name=?][value=?]', "issue[custom_field_values][#{@field.id}][p0][filename]", 'testfile.txt'

    issue = new_record(Issue) do

      assert_no_difference 'Attachment.count' do

        post '/projects/ecookbook/issues', {

            :issue => {

              :subject => "Subject",

              :custom_field_values => {

                @field.id => {:token => attachment.token}

              }

            }

          }

        assert_response 302

      end

    end

    custom_value = issue.custom_value_for(@field)

    assert custom_value

    assert_equal attachment.id.to_s, custom_value.value

    assert_equal custom_value, attachment.reload.container

  end

end

# 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__)

require 'redmine/field_format'

class Redmine::AttachmentFieldFormatTest < ActionView::TestCase

  include ApplicationHelper

  include Redmine::I18n

  fixtures :users

  def setup

    set_language_if_valid 'en'

    set_tmp_attachments_directory

  end

  def test_should_accept_a_hash_with_upload_on_create

    field = GroupCustomField.generate!(:name => "File", :field_format => 'attachment')

    group = Group.new(:name => 'Group')

    attachment = nil

    custom_value = new_record(CustomValue) do

      attachment = new_record(Attachment) do

        group.custom_field_values = {field.id => {:file => mock_file}}

        assert group.save

      end

    end

    assert_equal 'a_file.png', attachment.filename

    assert_equal custom_value, attachment.container

    assert_equal field, attachment.container.custom_field

    assert_equal group, attachment.container.customized

  end

  def test_should_accept_a_hash_with_no_upload_on_create

    field = GroupCustomField.generate!(:name => "File", :field_format => 'attachment')

    group = Group.new(:name => 'Group')

    attachment = nil

    custom_value = new_record(CustomValue) do

      assert_no_difference 'Attachment.count' do

        group.custom_field_values = {field.id => {}}

        assert group.save

      end

    end

    assert_equal '', custom_value.value

  end

  def test_should_not_validate_with_invalid_upload_on_create

    field = GroupCustomField.generate!(:name => "File", :field_format => 'attachment')

    group = Group.new(:name => 'Group')

    with_settings :attachment_max_size => 0 do

      assert_no_difference 'CustomValue.count' do

        assert_no_difference 'Attachment.count' do

          group.custom_field_values = {field.id => {:file => mock_file}}

          assert_equal false, group.save

        end

      end

    end

  end

  def test_should_accept_a_hash_with_token_on_create

    field = GroupCustomField.generate!(:name => "File", :field_format => 'attachment')

    group = Group.new(:name => 'Group')

    attachment = Attachment.create!(:file => mock_file, :author => User.find(2))

    assert_nil attachment.container

    custom_value = new_record(CustomValue) do

      assert_no_difference 'Attachment.count' do

        group.custom_field_values = {field.id => {:token => attachment.token}}

        assert group.save

      end

    end

    attachment.reload

    assert_equal custom_value, attachment.container

    assert_equal field, attachment.container.custom_field

    assert_equal group, attachment.container.customized

  end

  def test_should_not_validate_with_invalid_token_on_create

    field = GroupCustomField.generate!(:name => "File", :field_format => 'attachment')

    group = Group.new(:name => 'Group')

    assert_no_difference 'CustomValue.count' do

      assert_no_difference 'Attachment.count' do

        group.custom_field_values = {field.id => {:token => "123.0123456789abcdef"}}

        assert_equal false, group.save

      end

    end

  end

  def test_should_replace_attachment_on_update

    field = GroupCustomField.generate!(:name => "File", :field_format => 'attachment')

    group = Group.new(:name => 'Group')

    attachment = nil

    custom_value = new_record(CustomValue) do

      attachment = new_record(Attachment) do

        group.custom_field_values = {field.id => {:file => mock_file}}

        assert group.save

      end

    end

    group.reload

    assert_no_difference 'Attachment.count' do

      assert_no_difference 'CustomValue.count' do

        group.custom_field_values = {field.id => {:file => mock_file}}

        assert group.save

      end

    end

    assert !Attachment.exists?(attachment.id)

    assert CustomValue.exists?(custom_value.id)

    new_attachment = Attachment.order(:id => :desc).first

    custom_value.reload

    assert_equal custom_value, new_attachment.container

  end

  def test_should_delete_attachment_on_update

    field = GroupCustomField.generate!(:name => "File", :field_format => 'attachment')

    group = Group.new(:name => 'Group')

    attachment = nil

    custom_value = new_record(CustomValue) do

      attachment = new_record(Attachment) do

        group.custom_field_values = {field.id => {:file => mock_file}}

        assert group.save

      end

    end

    group.reload

    assert_difference 'Attachment.count', -1 do

      assert_no_difference 'CustomValue.count' do

        group.custom_field_values = {field.id => {}}

        assert group.save

      end

    end

    assert !Attachment.exists?(attachment.id)

    assert CustomValue.exists?(custom_value.id)

    custom_value.reload

    assert_equal '', custom_value.value

  end

end