Redmine

      unless issue.disabled_core_fields.include?(attribute+"_id") or issue.hidden_attribute_names(user).include?(attribute+"_id")

      unless (detail.property == 'cf' || detail.property == 'attr') &&  detail.journal.issue.hidden_attribute?(detail.prop_key, options[:user])

        if detail.property == 'cf'

          field = detail.custom_field

          if field && field.multiple?

            values_by_field[field] ||= {:added => [], :deleted => []}

            if detail.old_value

              values_by_field[field][:deleted] << detail.old_value

            end

            if detail.value

              values_by_field[field][:added] << detail.value

            end

            next

        strings << show_detail(detail, no_html, options)

      unless detail.journal.issue.hidden_attribute?(detail.prop_key, options[:user])

        detail.instance_variable_set "@custom_field", field

        if changes[:added].any?

          detail.value = changes[:added]

          strings << show_detail(detail, no_html, options)

        elsif changes[:deleted].any?

          detail.old_value = changes[:deleted]

          strings << show_detail(detail, no_html, options)

        end

    options << [l(:label_hidden), "hidden"]

    fields = custom_field_values.select do |value|

    fields = fields & viewable_custom_field_values(user_real)

    fields

  # Returns the custom_field_values that can be viewed by the given user

  # For now: just exclude Fix Info and RNs, as it is printed seperately below description.

  def viewable_custom_field_values(user=nil)

    custom_field_values.reject do |value|

      hidden_attribute_names(user).include?(value.custom_field_id.to_s)

    end

  end  

    workflow_rule_by_attribute(user).reject {|attr, rule| rule != 'readonly' and rule != 'hidden'}.keys

  # Same as above, but for hidden fields

  def hidden_attribute_names(user=nil)

    workflow_rule_by_attribute(user).reject {|attr, rule| rule != 'hidden'}.keys

  end

  # Returns true if the attribute should be hidden for user

  def hidden_attribute?(name, user=nil)

    hidden_attribute_names(user).include?(name.to_s)

  end  

  def each_notification(users, &block)   

      variations = users.collect {

        |user| (hidden_attribute_names(user) + (custom_field_values - visible_custom_field_values(user))).uniq

      }.uniq

      recipient_groups = Array.new(variations.count) { Array.new }

      users.each do |user|

        recipient_groups[variations.index(hidden_attribute_names(user))] << user

      recipient_groups.each do |group|

        yield(group)

      end

    end    

    if project == nil

      hidden_fields = []

      all_projects.each { |prj| 

        if prj.visible? and User.current.roles_for_project(prj).count > 0

          hidden_fields = hidden_fields == [] ? prj.completely_hidden_attribute_names : hidden_fields & prj.completely_hidden_attribute_names

        end

      }

    else

      hidden_fields = project.completely_hidden_attribute_names

    end

    hidden_fields.map! {|field| field.sub(/_id$/, '')}       

                           ).visible.collect {|cf| QueryCustomFieldColumn.new(cf) }.reject{|column| hidden_fields.include?(column.custom_field.id.to_s) }

    @available_columns.reject! {|column|

      hidden_fields.include?(column.name.to_s)

    }    

      if detail.property == 'attr'

        !issue.hidden_attribute?(detail.prop_key, user)

      elsif detail.property == 'cf'

        detail.custom_field && detail.custom_field.visible_by?(project, user) && !issue.hidden_attribute?(detail.prop_key, user)

  # Returns list of attributes that are hidden on all statuses of all trackers for +user+ or the current user.

  def completely_hidden_attribute_names(user=nil)

    user_real = user || User.current

    roles = user_real.admin ? Role.all : user_real.roles_for_project(self)

    return {} if roles.empty?

    result = {}

    workflow_permissions = WorkflowPermission.where(:tracker_id => trackers.map(&:id), :old_status_id => IssueStatus.all.map(&:id), :role_id => roles.map(&:id), :rule => 'hidden').all

    if workflow_permissions.any?

      workflow_rules = workflow_permissions.inject({}) do |h, wp|

        h[wp.field_name] ||= []

        h[wp.field_name] << wp.rule

        h

      end

      workflow_rules.each do |attr, rules|

        next if rules.size < (roles.size * trackers.size * IssueStatus.all.size)

        uniq_rules = rules.uniq

        if uniq_rules.size == 1

          result[attr] = uniq_rules.first

        else

          result[attr] = 'required'

        end

      end

    end

    result.keys    

  end  

    if object.respond_to?(:hidden_attribute_names)

      hidden_fields = object.hidden_attribute_names.map {|field| field.sub(/_id$/, '')}

      if hidden_fields.include?(name.to_s)

        ""

      else

        object.send name

      end

    else

      object.send name

    end    

    hidden_fields.each {|field|

      @available_filters.delete field

    }    

  def hidden_fields

    return @hidden_fields if @hidden_fields

    if project != nil

      @hidden_fields = project.completely_hidden_attribute_names

    else

      @hidden_fields = []

      usr = User.current;

      first = true

      all_projects.each { |prj|

        if prj.visible? and usr.roles_for_project(prj).count > 0

          if first

            @hidden_fields = prj.completely_hidden_attribute_names(usr)

          else

            @hidden_fields &= prj.completely_hidden_attribute_names(usr)

          end

          return @hidden_fields if @hidden_fields.empty?

        end

        first = false

      }

    end

    return @hidden_fields

  end

    unless hidden_fields.include?(field.id.to_s)

      case field.field_format

      when "text"

        options = { :type => :text }

      when "list"

        options = { :type => :list_optional, :values => field.possible_values }

      when "date"

        options = { :type => :date }

      when "bool"

        options = { :type => :list, :values => [[l(:general_text_yes), "1"], [l(:general_text_no), "0"]] }

      when "int"

        options = { :type => :integer }

      when "float"

        options = { :type => :float }

      when "user", "version"

        return unless project

        values = field.possible_values_options(project)

        if User.current.logged? && field.field_format == 'user'

          values.unshift ["<< #{l(:label_me)} >>", "me"]

        end

        options = { :type => :list_optional, :values => values }

      else

        options = { :type => :string }

      filter_id = "cf_#{field.id}"

      filter_name = field.name

      if assoc.present?

        filter_id = "#{assoc}.#{filter_id}"

        filter_name = l("label_attribute_of_#{assoc}", :name => filter_name)

      end

      add_available_filter filter_id, options.merge({

        :name => filter_name,

        :format => field.field_format,

        :field => field

      })

  validates_inclusion_of :rule, :in => %w(readonly required hidden)

  #   WorkflowPermission.replace_permissions role, tracker, {'due_date' => {'1' => 'readonly', '2' => 'required', '3' => 'hidden'}}

  <% if details_to_strings(journal.details).any? || journal.notes.blank? == false %>

    <div id="change-<%= journal.id %>" class="<%= journal.css_classes %>">

      <div id="note-<%= journal.indice %>">

      <h4><%= link_to "##{journal.indice}", {:anchor => "note-#{journal.indice}"}, :class => "journal-link" %>

      <%= avatar(journal.user, :size => "24") %>

      <%= authoring journal.created_on, journal.user, :label => :label_updated_time_by %></h4>

      <% if journal.details.any? %>

      <ul class="details">

        <% details_to_strings(journal.visible_details).each do |string| %>

         <li><%= string %></li>

        <% end %>

      </ul>

      <%= render_notes(issue, journal, :reply_links => reply_links) unless journal.notes.blank? %>

      </div>

    <%= call_hook(:view_issues_history_journal_bottom, { :journal => journal }) %>

  <% end %>

  unless @issue.hidden_attribute?('status')

    rows.left l(:field_status), h(@issue.status.name), :class => 'status_id'

  end

  unless @issue.hidden_attribute?('priority_id')

    rows.left l(:field_priority), h(@issue.priority.name), :class => 'priority_id'

  end  

  unless @issue.disabled_core_fields.include?('assigned_to_id') || @issue.hidden_attribute?('assigned_to_id')

  unless @issue.disabled_core_fields.include?('category_id') || @issue.hidden_attribute?('category_id')

  unless @issue.disabled_core_fields.include?('fixed_version_id') || @issue.hidden_attribute?('fixed_version_id')

  unless @issue.disabled_core_fields.include?('start_date') || @issue.hidden_attribute?('start_date')

  unless @issue.disabled_core_fields.include?('due_date') || @issue.hidden_attribute?('due_date')

  unless @issue.disabled_core_fields.include?('done_ratio') || @issue.hidden_attribute?('done_ratio')

  unless @issue.disabled_core_fields.include?('estimated_hours') || @issue.hidden_attribute?('estimated_hours')

<% details_to_strings(@journal_details, false, :only_path => false, :user => @auser).each do |string| %>

<% details_to_strings(@journal_details, true, :user => @auser).each do |string| -%>