Redmine

  label_hidden: " Hidden "

    local_viewablecf=issue.viewable_custom_field_values

    return if local_viewablecf.empty?

    half = (local_viewablecf.size / 2.0).ceil

      ordered_values << local_viewablecf[i]

      ordered_values << local_viewablecf[i + half]

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

	      if detail.property == 'cf'

      		field_id = detail.prop_key

      		field = CustomField.find_by_id(field_id)

      		if field && field.multiple?

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

      		  if detail.old_value

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

      		  end

      		  if detail.value

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

      		  end

      		  next

		      end

	      end

	      strings << show_detail(detail, no_html, options)

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

	      detail = JournalDetail.new(:property => 'cf', :prop_key => field_id)

	      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

      end	

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

	        if hidden_fields.include?(column.is_a?(QueryCustomFieldColumn) ? column.custom_field.id.to_s : column.name.to_s)  

            ""

            s = if column.is_a?(QueryCustomFieldColumn)

              cv = issue.custom_field_values.detect {|v| v.custom_field_id == column.custom_field.id}

              show_value(cv)

              value = column.value(issue)

              if value.is_a?(Date)

                format_date(value)

              elsif value.is_a?(Time)

                format_time(value)

              elsif value.is_a?(Float)

                ("%.2f" % value).gsub('.', decimal_separator)

              else

                value

              end

            s.to_s

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

  # 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 issue_add(issue, ausers)

    @auser = ausers[0]

    recipients = ausers.map(&:mail)

    cc = issue.watcher_recipient_users.map(&:mail).select {|rcpt| recipients.include?(rcpt)}

  #   issue_edit(journal, users) => Mail::Message object

  #   Mailer.issue_edit(journal, users).deliver => sends an email to +users+

  def issue_edit(journal, ausers)

    @auser = ausers[0]

    recipients = ausers.map(&:mail)

    cc = issue.watcher_recipient_users.map(&:mail).select {|rcpt| recipients.include?(rcpt)}

    recipients.reject! {|rcpt| cc.include?(rcpt)}

  def after_create(issue)    

    if Setting.notified_events.include?('issue_added')    

      recipients = issue.notified_users + issue.watcher_recipient_users

      if recipients.any?

        variations = recipients.collect { |user| issue.hidden_attribute_names(user) }.uniq

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

        recipients.each do |user|

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

        end

        recipient_groups.each do |group|

          Mailer.issue_add(issue, group).deliver

        end

      end

    end

  # 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

      recipients = journal.journalized.notified_users

      recipients += journal.journalized.watcher_recipient_users

      if journal.private_notes?

        recipients = recipients.select {|user| user.allowed_to?(:view_private_notes, journal.journalized.project)}

      end

      if recipients.any?

        variations = recipients.collect { |user| journal.issue.hidden_attribute_names(user) }.uniq

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

        recipients.each do |user|

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

        end

        recipient_groups.each do |group|

          Mailer.issue_edit(journal, group).deliver

        end

      end

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

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

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

    if hidden_fields.include?(name.to_s)

      ""

    else

      issue.send name

    end

    if project != nil

      hidden_fields = project.completely_hidden_attribute_names

    else

      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

      }

    end

    hidden_fields.each {|field|

      @available_filters.delete field

    }

    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$/, '')}

                           ).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)

    }

      unless project == nil or project.completely_hidden_attribute_names.include?(field.id.to_s)

        case field.field_format

        when "text"

          options = { :type => :text, :order => 20 }

        when "list"

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

        when "date"

          options = { :type => :date, :order => 20 }

        when "bool"

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

        when "int"

          options = { :type => :integer, :order => 20 }

        when "float"

          options = { :type => :float, :order => 20 }

        when "user", "version"

          next 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, :order => 20}

        else

          options = { :type => :string, :order => 20 }

        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

        @available_filters[filter_id] = options.merge({

                 :name => filter_name,

                 :format => field.field_format,

                 :field => field

               })

  <% 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.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'

  end

  unless @issue.hidden_attribute?('priority')

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

  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')

<% split_on = (@issue.editable_custom_field_values.size / 2.0).ceil - 1 %>

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

<%= render :partial => 'issue', :formats => [:html], :locals => { :issue => @issue, :issue_url => @issue_url, :user => @auser } %>

<% unless issue.hidden_attribute?('status', user) %>

<% end %>

<% unless issue.hidden_attribute?('priority', user) %>

<% end %>

<% unless issue.disabled_core_fields.include?('assigned_to_id') || issue.hidden_attribute?('assigned_to_id', user) %>

<% end %>

<% unless issue.disabled_core_fields.include?('category_id') || issue.hidden_attribute?('category_id', user) %>

<% end %>

<% unless issue.disabled_core_fields.include?('fixed_version_id') || issue.hidden_attribute?('fixed_version_id', user) %>

<% end %>

<% issue.custom_field_values.each do |c| %>

<% unless issue.hidden_attribute?(c.custom_field.id, user) %>

* <%= c.custom_field.name %>: <%= show_value(c) %>

<% end %>

<%= render :partial => 'issue', :formats => [:text], :locals => { :issue => @issue, :issue_url => @issue_url, :user => @auser } %>

<% unless issue.hidden_attribute?('status', user) %>

  <li><%=l(:field_status)%>: <%=h issue.status %></li>

<% end %>

<% unless issue.hidden_attribute?('priority', user) %>

  <li><%=l(:field_priority)%>: <%=h issue.priority %></li>

<% end %>

<% unless issue.disabled_core_fields.include?('assigned_to_id') || issue.hidden_attribute?('assigned_to_id', user) %>

  <li><%=l(:field_assigned_to)%>: <%=h issue.assigned_to %></li>

<% end %>

<% unless issue.disabled_core_fields.include?('category_id') || issue.hidden_attribute?('category_id', user) %>

  <li><%=l(:field_category)%>: <%=h issue.category %></li>

<% end %>

<% unless issue.disabled_core_fields.include?('fixed_version_id') || issue.hidden_attribute?('fixed_version_id', user) %>

  <li><%=l(:field_fixed_version)%>: <%=h issue.fixed_version %></li>

<% end %>

  <% unless issue.hidden_attribute?(c.custom_field.id, user) %>

    <li><%=h c.custom_field.name %>: <%=h show_value(c) %></li>

  <% end %>

<%= render :partial => 'issue', :formats => [:html], :locals => { :issue => @issue, :issue_url => @issue_url, :user => @auser } %>

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

<%= render :partial => 'issue', :formats => [:text], :locals => { :issue => @issue, :issue_url => @issue_url, :user => @auser } %>

        # Returns an array of watchers

        def watcher_recipient_users

          notified = watcher_users.active

          notified.reject! {|user| user.mail_notification == 'none'}

          if respond_to?(:visible?)

            notified.reject! {|user| !visible?(user)}

          end

          notified

        end