Redmine

  helper :projects

    @categories = @project.shared_categories.sort

      @rows = @project.shared_categories.sort

  def format_category_sharing(category, project)

    sharing = IssueCategory::SHARINGS.include?(category.sharing) ? category.sharing : 'none'

    project_name = category.project != project ? ' (' + category.project.name + ')' : ''

    l("label_version_sharing_#{sharing}") + project_name

  end

  def format_category_sharing_simple(sharing)

    sharing_label = IssueCategory::SHARINGS.include?(sharing) ? sharing : 'none'

    l("label_version_sharing_#{sharing_label}")

  end

      # Keep the category if it's still valid in the new_project

      unless new_project.shared_categories.include?(issue.category)

        # try to reassign to the category with same name if any

        new_category = issue.category.nil? ? nil : new_project.issue_categories.find_by_name(issue.category.name)

        issue.category = new_category

      end

    if category

      if !assignable_categories.include?(category)

        errors.add :category_id, :inclusion

      end

    end

  # Categories that the issue can be assigned to

  def assignable_categories

    @assignable_categories ||= (project.shared_categories + [IssueCategory.find_by_id(category_id_was)]).compact.uniq.sort

  end

  # Unassigns issues from +category+ if it's no longer shared with issue's project

  def self.update_categories_from_sharing_change(category)

    # Update issues assigned to the category

    update_categories(["#{Issue.table_name}.category_id = ?", category.id])

  end

  # Unassigns issues from categories that are no longer shared

  # after +project+ was moved

  def self.update_categories_from_hierarchy_change(project)

    moved_project_ids = project.self_and_descendants.reload.collect(&:id)

    # Update issues of the moved projects and issues assigned to a category of a moved project

    Issue.update_categories(["#{IssueCategory.table_name}.project_id IN (?) OR #{Issue.table_name}.project_id IN (?)", moved_project_ids, moved_project_ids])

  end

  # Update issues so their categories are not pointing to a

  # fixed_version that is not shared with the issue's project

  def self.update_categories(conditions=nil)

    # Only need to update issues with a fixed_version from

    # a different project and that is not systemwide shared

    Issue.all(:conditions => merge_conditions("#{Issue.table_name}.category_id IS NOT NULL" +

                                                " AND #{Issue.table_name}.project_id <> #{IssueCategory.table_name}.project_id" +

                                                " AND #{IssueCategory.table_name}.sharing <> 'system'",

                                                conditions),

              :include => [:project, :category]

              ).each do |issue|

      next if issue.project.nil? || issue.category.nil?

      unless issue.project.shared_categories.include?(issue.category)

        issue.init_journal(User.current)

        issue.category = nil

        issue.save

      end

    end

  end

  after_update :update_issues_from_sharing_change

  SHARINGS = %w(none descendants hierarchy tree system)

  validates_inclusion_of :sharing, :in => SHARINGS

  # Returns the sharings that +user+ can set the category to

  def allowed_sharings(user = User.current)

    SHARINGS.select do |s|

      if sharing == s

        true

      else

        case s

        when 'system'

          # Only admin users can set a systemwide sharing

          user.admin?

        when 'hierarchy', 'tree'

          # Only users allowed to manage categories of the root project can

          # set sharing to hierarchy or tree

          project.nil? || user.allowed_to?(:manage_categories, project.root)

        else

          true

        end

      end

    end

  end

  # Update the issue's fixed categories. Used if a category's sharing changes.

  def update_issues_from_sharing_change

    if sharing_changed?

      if SHARINGS.index(sharing_was).nil? ||

          SHARINGS.index(sharing).nil? ||

          SHARINGS.index(sharing_was) > SHARINGS.index(sharing)

        Issue.update_categories_from_sharing_change self

      end

    end

  end

      'category_id' => (k = get_keyword(:category)) && issue.project.shared_categories.named(k).first.try(:id),

      Issue.update_categories_from_hierarchy_change(self)

  # Returns a scope of the categories used by the project

  def shared_categories

    @shared_categories ||=

      IssueCategory.find(:all, :include => :project,

                     :conditions => "#{Project.table_name}.id = #{id}" +

                                    " OR (#{Project.table_name}.status = #{Project::STATUS_ACTIVE} AND (" +

                                          " #{IssueCategory.table_name}.sharing = 'system'" +

                                          " OR (#{Project.table_name}.lft >= #{root.lft} AND #{Project.table_name}.rgt <= #{root.rgt} AND #{IssueCategory.table_name}.sharing = 'tree')" +

                                          " OR (#{Project.table_name}.lft < #{lft} AND #{Project.table_name}.rgt > #{rgt} AND #{IssueCategory.table_name}.sharing IN ('hierarchy', 'descendants'))" +

                                          " OR (#{Project.table_name}.lft > #{lft} AND #{Project.table_name}.rgt < #{rgt} AND #{IssueCategory.table_name}.sharing = 'hierarchy')" +

                                          "))")

  end

      categories = project.shared_categories

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

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

    <% @project.shared_categories.each do |u| -%>

<p><%= f.select :sharing, @category.allowed_sharings.collect{|c| [format_category_sharing_simple(c), c]} %></p>

<% unless @issue.assignable_categories.empty? %>

<p><%= f.select :category_id, (@issue.assignable_categories.collect {|c| [c.name, c.id]}), :include_blank => true %>

<% if @project.shared_categories.any? %>

    <th><%= l(:field_sharing) %></th>

<% for category in @project.shared_categories %>

  <tr class="<%= cycle 'odd', 'even' %> <%= 'shared' if category.project != @project %>">

    <td class="sharing"><%=h format_category_sharing(category, @project) %></td>

class AddIssueCategorySharing < ActiveRecord::Migration

  def self.up

    add_column :issue_categories, :sharing, :string, :default => 'none', :null => false

    add_index :issue_categories, :sharing

  end

  def self.down

    remove_column :issue_categories, :sharing

  end

end