Redmine

      fixed_version = (params[:fixed_version_id].blank? || params[:fixed_version_id] == 'none') ? nil : @project.inherited_versions.find {|v| v.id.to_s == params[:fixed_version_id] }

    # Need get the ids separately in order to add the finder options

    version_ids = @project.inherited_versions_visible_to_user.collect(&:id)

    @containers += Version.find_all_by_id(version_ids, :include => :attachments, :order => sort_clause).sort.reverse

    if params[:inherited_versions]

      @versions = @project.inherited_versions_visible_to_user.sort

    else

      @versions = @project.versions.sort

    end

    if params[:inherited_versions]

      @versions = @project.inherited_versions_visible_to_user.sort

    else

      @versions = @project.versions.sort

    end

  def format_version_name(version)

    if User.current.allowed_to?(:view_issues, version.project)

      "#{h(version.project.name)} - #{h(version.name)}"

    else

      "#{l(:text_not_authorized)}"

    end

  end

  # Given an Array of emails (+recipients+), do they all have

  # +permission+ on +project+ ?

  def recipients_all_allowed_to?(recipients, permission, project)

    recipients.uniq.all? do |recipient|

      user = User.find_by_mail(recipient)

      user && user.allowed_to?(permission, project)

    end

  end

  # Given an Array of +versions+, are all the email addresses

  # (+recipients+) allowed to view all of the versions?

  def recipients_all_allowed_to_see_versions?(recipients, versions)

    versions.uniq.all? do |version|

      if version.nil?

        true

      else

        recipients_all_allowed_to?(recipients, :view_issues, version.project)

      end

    end

  end

  def inherited_version_options(project)

    project.inherited_versions.sort.collect {|v| [format_version_name(v), v.id] }

  end

        v = Version.find_by_id(detail.value) and value = format_version_name(v) if detail.value

        v = Version.find_by_id(detail.old_value) and old_value = format_version_name(v) if detail.old_value

# redMine - project management software

# Copyright (C) 2006-2009  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 MailerHelper

  def unauthorized_version?(journal_detail, recipients)

    return false unless journal_detail.prop_key == "fixed_version_id"

    !recipients_all_allowed_to_see_versions?(recipients,

                                             Version.find_all_by_id([journal_detail.value, journal_detail.old_value]))

  end

end

    if User.current.allowed_to?(:view_issues, version.project)

      link_to format_version_name(version), { :controller => 'versions', :action => 'show', :id => version }, options

    else

      format_version_name(version)

    end

  helper :mailer

  # Returns an array of the Versions used by the project, its active

  # sub projects, and its active parent projects

  def inherited_versions

    @inherited_versions ||= self.root.self_and_descendants.

      delete_if {|p| !p.active? }.

      collect(&:versions).

      flatten.

      sort

    yield @inherited_versions if block_given?

    @inherited_versions

  end

  # Returns the inherited_versions that are visible to +user+

  def inherited_versions_visible_to_user(user=User.current)

    return inherited_versions do |versions|

      versions.delete_if {|v| !user.allowed_to?(:view_issues, v.project) }

    end

  end

        @available_filters["fixed_version_id"] = { :type => :list_optional, :order => 7, :values => @project.inherited_versions.sort.collect{|s| ["#{s.project.name} - #{s.name}", s.id.to_s] } }

                              (inherited_version_options(@project)),

                              { :include_blank => true })) unless @project.inherited_versions.empty? %>

                                   options_for_select(inherited_version_options(@project))) %></label>

	<% unless @project.nil? || @project.inherited_versions.empty? -%>

		<% @project.inherited_versions.sort.each do |v| -%>

		    <li><%= context_menu_link format_version_name(v), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), 'fixed_version_id' => v, :back_to => @back}, :method => :post,

<% if unauthorized_version?(detail, @recipients + @cc) %>

    <li><%= l(:field_fixed_version) %> <%= l(:text_journal_set_to, l(:text_not_authorized)) %></li>

    <% else %>

    <% end %>

<% if unauthorized_version?(detail, @recipients + @cc) %>

<%= l(:field_fixed_version) %> <%= l(:text_journal_set_to, l(:text_not_authorized)) %>

<% else %>

<% end %>

<br />

<label for="inherited_versions"><%= check_box_tag "inherited_versions", 1, params[:inherited_versions] %> <%= l(:label_show_inherited_versions) %></label>

  		<%= link_to(h(container.project.name) + ' - ' + h(container), {:controller => 'versions', :action => 'show', :id => container}, :class => "icon icon-package") %>

    <h3 class="icon22 icon22-package"><%= link_to h(version.project.name) + " - " + h(version.name), :controller => 'versions', :action => 'show', :id => version %></h3>

<br />

<label for="inherited_versions"><%= check_box_tag "inherited_versions", 1, params[:inherited_versions] %> <%= l(:label_show_inherited_versions) %></label>

  label_show_inherited_versions: Show inherited versions

  text_not_authorized: You are not authorized to view this.

attachments_011: 

  created_on: 2006-07-19 21:07:27 +02:00

  container_type: Version

  container_id: 1

  downloads: 0

  disk_filename: 060719210727_version_file.zip

  digest: b91e08d0cf966d5c6ff411bd8c4cc3a2

  id: 11

  filesize: 452

  filename: version_file.zip

  author_id: 2

  content_type: application/octet-stream

journal_details_003: 

  old_value: nil

  property: attr

  id: 3

  value: "6"

  prop_key: fixed_version_id

  journal_id: 4

journals_004: 

  created_on: <%= 1.days.ago.to_date.to_s(:db) %>

  notes: "A comment with a private version."

  id: 4

  journalized_type: Issue

  user_id: 1

  journalized_id: 6

members_006: 

  created_on: 2006-07-19 19:35:33 +02:00

  project_id: 5

  id: 6

  user_id: 1

  mail_notification: true

versions_004: 

  created_on: 2006-07-19 21:00:33 +02:00

  name: "2.0"

  project_id: 3

  updated_on: 2006-07-19 21:00:33 +02:00

  id: 4

  description: Future version on subproject

  effective_date: 

versions_005: 

  created_on: 2006-07-19 21:00:07 +02:00

  name: "Alpha"

  project_id: 2

  updated_on: 2006-07-19 21:00:07 +02:00

  id: 5

  description: Private Alpha

  effective_date: 2006-07-01

versions_006: 

  created_on: 2006-07-19 21:00:07 +02:00

  name: "Private Version of public subproject"

  project_id: 5

  updated_on: 2006-07-19 21:00:07 +02:00

  id: 6

  description: "Should be done any day now..."

  effective_date: 

  def test_post_edit_should_allow_fixed_version_to_be_set_to_a_subproject

    issue = Issue.find(2)

    @request.session[:user_id] = 2

    post :edit,

         :id => issue.id,

         :issue => {

           :fixed_version_id => 4

         }

    assert_response :redirect

    issue.reload

    assert_equal 4, issue.fixed_version_id

    assert_not_equal issue.project_id, issue.fixed_version.project_id

  end

  def test_post_bulk_edit_should_allow_fixed_version_to_be_set_to_a_subproject

    @request.session[:user_id] = 2

    post :bulk_edit,

         :ids => [1,2],

         :fixed_version_id => 4

    assert_response :redirect

    issues = Issue.find([1,2])

    issues.each do |issue|

      assert_equal 4, issue.fixed_version_id

      assert_not_equal issue.project_id, issue.fixed_version.project_id

    end

  end

    # Versions

    assert_tag :tag => 'a', :content => 'eCookbook - 0.1',

                            :attributes => { :href => '/issues/bulk_edit?fixed_version_id=1&ids%5B%5D=1',

                                             :class => '' }

    assert_tag :tag => 'a', :content => 'eCookbook - 1.0',

                            :attributes => { :href => '/issues/bulk_edit?fixed_version_id=2&ids%5B%5D=1',

                                             :class => '' }

    assert_tag :tag => 'a', :content => 'eCookbook Subproject 1 - 2.0',

                            :attributes => { :href => '/issues/bulk_edit?fixed_version_id=4&ids%5B%5D=1',

                                             :class => '' }

  def test_list_files_with_inherited_versions

    get :list_files, :id => 1

    assert_response :success

    assert_not_nil assigns(:containers)

    # file attached to a subproject's version

    assert_tag :a, :content => 'version_file.zip',

                   :attributes => { :href => '/attachments/download/11/version_file.zip' }

  end

  def test_changelog_showing_inherited_versions

    get :changelog, :id => 1, :inherited_versions => 1

    assert_response :success

    assert_template 'changelog'

    assert_not_nil assigns(:versions)

    # Version on subproject appears

    assert assigns(:versions).include?(Version.find(4))

  end

  def test_roadmap_showing_inherited_versions

    get :roadmap, :id => 1, :inherited_versions => 1

    assert_response :success

    assert_template 'roadmap'

    assert_not_nil assigns(:versions)

    # Version on subproject appears

    assert assigns(:versions).include?(Version.find(4))

  end

  def test_format_version_name_is_authorized

    User.current = User.find(1)

    assert_equal "eCookbook - 0.1", format_version_name(Version.find(1))

  end

  def test_format_version_name_is_unauthorized

    User.current = User.find(3)

    assert_equal "You are not authorized to view this.", format_version_name(Version.find(5))

  end

# Redmine - project management software

# Copyright (C) 2006-2009  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.dirname(__FILE__) + '/../../test_helper'

class ProjectsHelperTest < HelperTestCase

  include ApplicationHelper

  include ProjectsHelper

  fixtures :all

  def setup

    super

    set_language_if_valid('en')

  end

  def test_link_to_version

    User.current = User.find(1)

    assert_equal '<a href="/versions/show/1">eCookbook - 0.1</a>', link_to_version(Version.find(1))

  end

  def test_link_to_version_invalid_version

    assert_equal '', link_to_version(Object)

  end

  def test_link_to_version_unauthorized

    User.current = User.find(3)

    assert_equal "You are not authorized to view this.", link_to_version(Version.find(5))

  end

end

  def test_issue_edit_should_not_show_private_version_changes_if_any_recipients_are_unauthorized

    Setting.default_language = 'en'

    # Move issue to a public project but with a Journal showing a

    # Private Version

    issue = Issue.find(6)

    issue.update_attribute(:project_id, 1)

    # User is allowed to see the Private Version

    User.current = User.find(1)

    # but another Member of Project #1 is not (dlopper@somenet.foo)

    journal = Journal.find(4)

    Mailer.deliver_issue_edit(journal)

    mail = ActionMailer::Base.deliveries.last

    assert !mail.body.include?('Private Version of public subproject'), "Private version exposed to unauthorized user"

    assert mail.body.include?('You are not authorized to view this.'), "Unauthorized message not displayed"

  end

           :queries, :versions

  def test_inherited_versions

    parent = Project.find(1)

    child = parent.children.find(3)

    assert [1,2,3], parent.version_ids

    assert [4], child.version_ids

    assert_equal 5, parent.inherited_versions.size

    parent.inherited_versions.each do |version|

      assert_kind_of Version, version

    end

    assert_equal [1,2,3,4,6], parent.inherited_versions.collect(&:id)

  end

  def test_inherited_versions_should_ignore_archived_subprojects

    parent = Project.find(1)

    child = parent.children.find(3)

    child.archive

    parent.reload

    assert [1,2,3], parent.version_ids

    assert [4], child.version_ids

    assert !parent.inherited_versions.collect(&:id).include?(4)

  end

  def test_inherited_versions_visible_to_user

    user = User.find(3)

    parent = Project.find(1)

    child = parent.children.find(5)

    assert [1,2,3], parent.version_ids

    assert [6], child.version_ids

    versions = parent.inherited_versions_visible_to_user(user)

    assert_equal 4, versions.size

    versions.each do |version|

      assert_kind_of Version, version

    end

    assert !versions.collect(&:id).include?(6)

  end

  def test_query_should_allow_inherited_versions_for_a_project_query

    subproject_version = Version.find(4)

    query = Query.new(:project => Project.find(1), :name => '_')

    query.add_filter('fixed_version_id', '=', [subproject_version.id.to_s])

    assert query.statement.include?("#{Issue.table_name}.fixed_version_id IN ('4')")

  end