jro_apps/redmine Commit - r1813:455abea32042

Adds a permission 'view wiki edits' so that wiki history can be hidden to certain users (#1154)....

Jean-Philippe Lang -

r1813:455abea32042

parent child

Context file:

r1813:455abea32042

Collapse all files

db/migrate/097_add_wiew_wiki_edits_permission.rb created 644 +13 0

@@ -0,0 +1,13
	1	class AddWiewWikiEditsPermission < ActiveRecord::Migration
	2	def self.up
	3	Role.find(:all).each do \|r\|
	4	r.add_permission!(:view_wiki_edits) if r.has_permission?(:view_wiki_pages)
	5	end
	6	end
	7
	8	def self.down
	9	Role.find(:all).each do \|r\|
	10	r.remove_permission!(:view_wiki_edits)
	11	end
	12	end
	13	end

app/controllers/wiki_controller.rb +5 0

             # redMine - project management software
             # Copyright (C) 2006-2007  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 'diff'
             class WikiController < ApplicationController
               before_filter :find_wiki, :authorize
               verify :method => :post, :only => [:destroy, :destroy_attachment, :protect], :redirect_to => { :action => :index }
               helper :attachments
               include AttachmentsHelper
               # display a page (in editing mode if it doesn't exist)
               def index
                 page_title = params[:page]
                 @page = @wiki.find_or_new_page(page_title)
                 if @page.new_record?
                   if User.current.allowed_to?(:edit_wiki_pages, @project)
                     edit
                     render :action => 'edit'
                   else
                     render_404
                   end
                   return
                 end
+                if params[:version] && !User.current.allowed_to?(:view_wiki_edits, @project)
+                  # Redirects user to the current version if he's not allowed to view previous versions
+                  redirect_to :version => nil
+                  return
+                end
                 @content = @page.content_for_version(params[:version])
                 if params[:export] == 'html'
                   export = render_to_string :action => 'export', :layout => false
                   send_data(export, :type => 'text/html', :filename => "#{@page.title}.html")
                   return
                 elsif params[:export] == 'txt'
                   send_data(@content.text, :type => 'text/plain', :filename => "#{@page.title}.txt")
                   return
                 end
             	@editable = editable?
                 render :action => 'show'
               end
               # edit an existing page or a new one
               def edit
                 @page = @wiki.find_or_new_page(params[:page])
                 return render_403 unless editable?
                 @page.content = WikiContent.new(:page => @page) if @page.new_record?
                 @content = @page.content_for_version(params[:version])
                 @content.text = "h1. #{@page.pretty_title}" if @content.text.blank?
                 # don't keep previous comment
                 @content.comments = nil
                 if request.post?
                   if !@page.new_record? && @content.text == params[:content][:text]
                     # don't save if text wasn't changed
                     redirect_to :action => 'index', :id => @project, :page => @page.title
                     return
                   end
                   #@content.text = params[:content][:text]
                   #@content.comments = params[:content][:comments]
                   @content.attributes = params[:content]
                   @content.author = User.current
                   # if page is new @page.save will also save content, but not if page isn't a new record
                   if (@page.new_record? ? @page.save : @content.save)
                     redirect_to :action => 'index', :id => @project, :page => @page.title
                   end
                 end
               rescue ActiveRecord::StaleObjectError
                 # Optimistic locking exception
                 flash[:error] = l(:notice_locking_conflict)
               end
               # rename a page
               def rename
                 @page = @wiki.find_page(params[:page])
             	return render_403 unless editable?
                 @page.redirect_existing_links = true
                 # used to display the *original* title if some AR validation errors occur
                 @original_title = @page.pretty_title
                 if request.post? && @page.update_attributes(params[:wiki_page])
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to :action => 'index', :id => @project, :page => @page.title
                 end
               end
               def protect
                 page = @wiki.find_page(params[:page])
                 page.update_attribute :protected, params[:protected]
                 redirect_to :action => 'index', :id => @project, :page => page.title
               end
               # show page history
               def history
                 @page = @wiki.find_page(params[:page])
                 @version_count = @page.content.versions.count
                 @version_pages = Paginator.new self, @version_count, per_page_option, params['p']
                 # don't load text
                 @versions = @page.content.versions.find :all,
                                                         :select => "id, author_id, comments, updated_on, version",
                                                         :order => 'version DESC',
                                                         :limit  =>  @version_pages.items_per_page + 1,
                                                         :offset =>  @version_pages.current.offset
                 render :layout => false if request.xhr?
               end
               def diff
                 @page = @wiki.find_page(params[:page])
                 @diff = @page.diff(params[:version], params[:version_from])
                 render_404 unless @diff
               end
               def annotate
                 @page = @wiki.find_page(params[:page])
                 @annotate = @page.annotate(params[:version])
               end
               # remove a wiki page and its history
               def destroy
                 @page = @wiki.find_page(params[:page])
             	return render_403 unless editable?
                 @page.destroy if @page
                 redirect_to :action => 'special', :id => @project, :page => 'Page_index'
               end
               # display special pages
               def special
                 page_title = params[:page].downcase
                 case page_title
                 # show pages index, sorted by title
                 when 'page_index', 'date_index'
                   # eager load information about last updates, without loading text
                   @pages = @wiki.pages.find :all, :select => "#{WikiPage.table_name}.*, #{WikiContent.table_name}.updated_on",
                                                   :joins => "LEFT JOIN #{WikiContent.table_name} ON #{WikiContent.table_name}.page_id = #{WikiPage.table_name}.id",
                                                   :order => 'title'
                   @pages_by_date = @pages.group_by {|p| p.updated_on.to_date}
                   @pages_by_parent_id = @pages.group_by(&:parent_id)
                 # export wiki to a single html file
                 when 'export'
                   @pages = @wiki.pages.find :all, :order => 'title'
                   export = render_to_string :action => 'export_multiple', :layout => false
                   send_data(export, :type => 'text/html', :filename => "wiki.html")
                   return
                 else
                   # requested special page doesn't exist, redirect to default page
                   redirect_to :action => 'index', :id => @project, :page => nil and return
                 end
                 render :action => "special_#{page_title}"
               end
               def preview
                 page = @wiki.find_page(params[:page])
                 # page is nil when previewing a new page
                 return render_403 unless page.nil? || editable?(page)
                 if page
                   @attachements = page.attachments
                   @previewed = page.content
                 end
                 @text = params[:content][:text]
                 render :partial => 'common/preview'
               end
               def add_attachment
                 @page = @wiki.find_page(params[:page])
                 return render_403 unless editable?
                 attach_files(@page, params[:attachments])
                 redirect_to :action => 'index', :page => @page.title
               end
               def destroy_attachment
                 @page = @wiki.find_page(params[:page])
                 return render_403 unless editable?
                 @page.attachments.find(params[:attachment_id]).destroy
                 redirect_to :action => 'index', :page => @page.title
               end
             private
               def find_wiki
                 @project = Project.find(params[:id])
                 @wiki = @project.wiki
                 render_404 unless @wiki
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Returns true if the current user is allowed to edit the page, otherwise false
               def editable?(page = @page)
                 page.editable_by?(User.current)
               end
             end

app/models/role.rb +5 0

             # redMine - project management software
             # Copyright (C) 2006  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.
             class Role < ActiveRecord::Base
               # Built-in roles
               BUILTIN_NON_MEMBER = 1
               BUILTIN_ANONYMOUS  = 2
               named_scope :builtin, lambda { |*args|
                 compare = 'not' if args.first == true
                 { :conditions => "#{compare} builtin = 0" }
               }
               before_destroy :check_deletable
               has_many :workflows, :dependent => :delete_all do
                 def copy(role)
                   raise "Can not copy workflow from a #{role.class}" unless role.is_a?(Role)
                   raise "Can not copy workflow from/to an unsaved role" if proxy_owner.new_record? || role.new_record?
                   clear
                   connection.insert "INSERT INTO workflows (tracker_id, old_status_id, new_status_id, role_id)" +
                                     " SELECT tracker_id, old_status_id, new_status_id, #{proxy_owner.id}" +
                                     " FROM workflows" +
                                     " WHERE role_id = #{role.id}"
                 end
               end
               has_many :members
               acts_as_list
               serialize :permissions, Array
               attr_protected :builtin
               validates_presence_of :name
               validates_uniqueness_of :name
               validates_length_of :name, :maximum => 30
               validates_format_of :name, :with => /^[\w\s\'\-]*$/i
               def permissions
                 read_attribute(:permissions) || []
               end
               def permissions=(perms)
                 perms = perms.collect {|p| p.to_sym unless p.blank? }.compact.uniq if perms
                 write_attribute(:permissions, perms)
               end
               def add_permission!(*perms)
                 self.permissions = [] unless permissions.is_a?(Array)
                 permissions_will_change!
                 perms.each do |p|
                   p = p.to_sym
                   permissions << p unless permissions.include?(p)
                 end
                 save!
               end
               def remove_permission!(*perms)
                 return unless permissions.is_a?(Array)
                 permissions_will_change!
                 perms.each { |p| permissions.delete(p.to_sym) }
                 save!
               end
+              # Returns true if the role has the given permission
+              def has_permission?(perm)
+                !permissions.nil? && permissions.include?(perm.to_sym)
+              end
               def <=>(role)
                 position <=> role.position
               end
               # Return true if the role is a builtin role
               def builtin?
                 self.builtin != 0
               end
               # Return true if the role is a project member role
               def member?
                 !self.builtin?
               end
               # Return true if role is allowed to do the specified action
               # action can be:
               # * a parameter-like Hash (eg. :controller => 'projects', :action => 'edit')
               # * a permission Symbol (eg. :edit_project)
               def allowed_to?(action)
                 if action.is_a? Hash
                   allowed_actions.include? "#{action[:controller]}/#{action[:action]}"
                 else
                   allowed_permissions.include? action
                 end
               end
               # Return all the permissions that can be given to the role
               def setable_permissions
                 setable_permissions = Redmine::AccessControl.permissions - Redmine::AccessControl.public_permissions
                 setable_permissions -= Redmine::AccessControl.members_only_permissions if self.builtin == BUILTIN_NON_MEMBER
                 setable_permissions -= Redmine::AccessControl.loggedin_only_permissions if self.builtin == BUILTIN_ANONYMOUS
                 setable_permissions
               end
               # Find all the roles that can be given to a project member
               def self.find_all_givable
                 find(:all, :conditions => {:builtin => 0}, :order => 'position')
               end
               # Return the builtin 'non member' role
               def self.non_member
                 find(:first, :conditions => {:builtin => BUILTIN_NON_MEMBER}) || raise('Missing non-member builtin role.')
               end
               # Return the builtin 'anonymous' role
               def self.anonymous
                 find(:first, :conditions => {:builtin => BUILTIN_ANONYMOUS}) || raise('Missing anonymous builtin role.')
               end
             private
               def allowed_permissions
                 @allowed_permissions ||= permissions + Redmine::AccessControl.public_permissions.collect {|p| p.name}
               end
               def allowed_actions
                 @actions_allowed ||= allowed_permissions.inject([]) { |actions, permission| actions += Redmine::AccessControl.allowed_actions(permission) }.flatten
               end
               def check_deletable
                 raise "Can't delete role" if members.any?
                 raise "Can't delete builtin role" if builtin?
               end
             end

app/models/wiki_content.rb +2 -2

             # redMine - project management software
             # Copyright (C) 2006-2007  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 'zlib'
             class WikiContent < ActiveRecord::Base
               set_locking_column :version
               belongs_to :page, :class_name => 'WikiPage', :foreign_key => 'page_id'
               belongs_to :author, :class_name => 'User', :foreign_key => 'author_id'
               validates_presence_of :text
               acts_as_versioned
               class Version
                 belongs_to :page, :class_name => '::WikiPage', :foreign_key => 'page_id'
                 belongs_to :author, :class_name => '::User', :foreign_key => 'author_id'
                 attr_protected :data
                 acts_as_event :title => Proc.new {|o| "#{l(:label_wiki_edit)}: #{o.page.title} (##{o.version})"},
                               :description => :comments,
                               :datetime => :updated_on,
                               :type => 'wiki-page',
                               :url => Proc.new {|o| {:controller => 'wiki', :id => o.page.wiki.project_id, :page => o.page.title, :version => o.version}}
-                acts_as_activity_provider :type => 'wiki_pages',
+                acts_as_activity_provider :type => 'wiki_edits',
                                           :timestamp => "#{WikiContent.versioned_table_name}.updated_on",
-                                          :permission => :view_wiki_pages,
+                                          :permission => :view_wiki_edits,
                                           :find_options => {:select => "#{WikiContent.versioned_table_name}.updated_on, #{WikiContent.versioned_table_name}.comments, " +
                                                                        "#{WikiContent.versioned_table_name}.#{WikiContent.version_column}, #{WikiPage.table_name}.title, " +
                                                                        "#{WikiContent.versioned_table_name}.page_id, #{WikiContent.versioned_table_name}.author_id, " +
                                                                        "#{WikiContent.versioned_table_name}.id",
                                                             :joins => "LEFT JOIN #{WikiPage.table_name} ON #{WikiPage.table_name}.id = #{WikiContent.versioned_table_name}.page_id " +
                                                                       "LEFT JOIN #{Wiki.table_name} ON #{Wiki.table_name}.id = #{WikiPage.table_name}.wiki_id " +
                                                                       "LEFT JOIN #{Project.table_name} ON #{Project.table_name}.id = #{Wiki.table_name}.project_id"}
                 def text=(plain)
                   case Setting.wiki_compression
                   when 'gzip'
                   begin
                     self.data = Zlib::Deflate.deflate(plain, Zlib::BEST_COMPRESSION)
                     self.compression = 'gzip'
                   rescue
                     self.data = plain
                     self.compression = ''
                   end
                   else
                     self.data = plain
                     self.compression = ''
                   end
                   plain
                 end
                 def text
                   @text ||= case compression
                   when 'gzip'
                      Zlib::Inflate.inflate(data)
                   else
                     # uncompressed data
                     data
                   end
                 end
                 def project
                   page.project
                 end
                 # Returns the previous version or nil
                 def previous
                   @previous ||= WikiContent::Version.find(:first,
                                                           :order => 'version DESC',
                                                           :include => :author,
                                                           :conditions => ["wiki_content_id = ? AND version < ?", wiki_content_id, version])
                 end
               end
             end

app/views/wiki/show.rhtml +1 -1

             <div class="contextual">
             <% if @editable %>
             <%= link_to_if_authorized(l(:button_edit), {:action => 'edit', :page => @page.title}, :class => 'icon icon-edit', :accesskey => accesskey(:edit)) if @content.version == @page.content.version %>
             <%= link_to_if_authorized(l(:button_lock), {:action => 'protect', :page => @page.title, :protected => 1}, :method => :post, :class => 'icon icon-lock') if !@page.protected? %>
             <%= link_to_if_authorized(l(:button_unlock), {:action => 'protect', :page => @page.title, :protected => 0}, :method => :post, :class => 'icon icon-unlock') if @page.protected? %>
             <%= link_to_if_authorized(l(:button_rename), {:action => 'rename', :page => @page.title}, :class => 'icon icon-move') if @content.version == @page.content.version %>
             <%= link_to_if_authorized(l(:button_delete), {:action => 'destroy', :page => @page.title}, :method => :post, :confirm => l(:text_are_you_sure), :class => 'icon icon-del') %>
             <%= link_to_if_authorized(l(:button_rollback), {:action => 'edit', :page => @page.title, :version => @content.version }, :class => 'icon icon-cancel') if @content.version < @page.content.version %>
             <% end %>
-            <%= link_to(l(:label_history), {:action => 'history', :page => @page.title}, :class => 'icon icon-history') %>
+            <%= link_to_if_authorized(l(:label_history), {:action => 'history', :page => @page.title}, :class => 'icon icon-history') %>
             </div>
             <%= breadcrumb(@page.ancestors.reverse.collect {|parent| link_to h(parent.pretty_title), {:page => parent.title}}) %>
             <% if @content.version != @page.content.version %>
                 <p>
                 <%= link_to(('&#171; ' + l(:label_previous)), :action => 'index', :page => @page.title, :version => (@content.version - 1)) + " - " if @content.version > 1 %>
                 <%= "#{l(:label_version)} #{@content.version}/#{@page.content.version}" %>
                 <%= '(' + link_to('diff', :controller => 'wiki', :action => 'diff', :page => @page.title, :version => @content.version) + ')' if @content.version > 1 %> -
                 <%= link_to((l(:label_next) + ' &#187;'), :action => 'index', :page => @page.title, :version => (@content.version + 1)) + " - " if @content.version < @page.content.version %>
                 <%= link_to(l(:label_current_version), :action => 'index', :page => @page.title) %>
                 <br />
                 <em><%= @content.author ? @content.author.name : "anonyme" %>, <%= format_time(@content.updated_on) %> </em><br />
                 <%=h @content.comments %>
                 </p>
                 <hr />
             <% end %>
             <%= render(:partial => "wiki/content", :locals => {:content => @content}) %>
             <%= link_to_attachments @page.attachments, :delete_url => ((@editable && authorize_for('wiki', 'destroy_attachment')) ? {:controller => 'wiki', :action => 'destroy_attachment', :page => @page.title} : nil) %>
             <% if @editable && authorize_for('wiki', 'add_attachment') %>
             <p><%= link_to l(:label_attachment_new), {}, :onclick => "Element.show('add_attachment_form'); Element.hide(this); Element.scrollTo('add_attachment_form'); return false;",
                                                          :id => 'attach_files_link' %></p>
             <% form_tag({ :controller => 'wiki', :action => 'add_attachment', :page => @page.title }, :multipart => true, :id => "add_attachment_form", :style => "display:none;") do %>
               <div class="box">
               <p><%= render :partial => 'attachments/form' %></p>
               </div>
             <%= submit_tag l(:button_add) %>
             <%= link_to l(:button_cancel), {}, :onclick => "Element.hide('add_attachment_form'); Element.show('attach_files_link'); return false;" %>
             <% end %>
             <% end %>
             <p class="other-formats">
             <%= l(:label_export_to) %>
             <span><%= link_to 'HTML', {:page => @page.title, :export => 'html', :version => @content.version}, :class => 'html' %></span>
             <span><%= link_to 'TXT', {:page => @page.title, :export => 'txt', :version => @content.version}, :class => 'text' %></span>
             </p>
             <% content_for :header_tags do %>
               <%= stylesheet_link_tag 'scm' %>
             <% end %>
             <% content_for :sidebar do %>
               <%= render :partial => 'sidebar' %>
             <% end %>
             <% html_title @page.pretty_title %>

lib/redmine.rb +3 -2

             require 'redmine/access_control'
             require 'redmine/menu_manager'
             require 'redmine/activity'
             require 'redmine/mime_type'
             require 'redmine/core_ext'
             require 'redmine/themes'
             require 'redmine/hook'
             require 'redmine/plugin'
             begin
               require_library_or_gem 'RMagick' unless Object.const_defined?(:Magick)
             rescue LoadError
               # RMagick is not available
             end
             REDMINE_SUPPORTED_SCM = %w( Subversion Darcs Mercurial Cvs Bazaar Git Filesystem )
             # Permissions
             Redmine::AccessControl.map do |map|
               map.permission :view_project, {:projects => [:show, :activity]}, :public => true
               map.permission :search_project, {:search => :index}, :public => true
               map.permission :edit_project, {:projects => [:settings, :edit]}, :require => :member
               map.permission :select_project_modules, {:projects => :modules}, :require => :member
               map.permission :manage_members, {:projects => :settings, :members => [:new, :edit, :destroy]}, :require => :member
               map.permission :manage_versions, {:projects => [:settings, :add_version], :versions => [:edit, :destroy]}, :require => :member
               map.project_module :issue_tracking do |map|
                 # Issue categories
                 map.permission :manage_categories, {:projects => [:settings, :add_issue_category], :issue_categories => [:edit, :destroy]}, :require => :member
                 # Issues
                 map.permission :view_issues, {:projects => [:changelog, :roadmap],
                                               :issues => [:index, :changes, :show, :context_menu],
                                               :versions => [:show, :status_by],
                                               :queries => :index,
                                               :reports => :issue_report}, :public => true
                 map.permission :add_issues, {:issues => :new}
                 map.permission :edit_issues, {:issues => [:edit, :reply, :bulk_edit, :destroy_attachment]}
                 map.permission :manage_issue_relations, {:issue_relations => [:new, :destroy]}
                 map.permission :add_issue_notes, {:issues => [:edit, :reply]}
                 map.permission :edit_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :edit_own_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :move_issues, {:issues => :move}, :require => :loggedin
                 map.permission :delete_issues, {:issues => :destroy}, :require => :member
                 # Queries
                 map.permission :manage_public_queries, {:queries => [:new, :edit, :destroy]}, :require => :member
                 map.permission :save_queries, {:queries => [:new, :edit, :destroy]}, :require => :loggedin
                 # Gantt & calendar
                 map.permission :view_gantt, :issues => :gantt
                 map.permission :view_calendar, :issues => :calendar
                 # Watchers
                 map.permission :view_issue_watchers, {}
                 map.permission :add_issue_watchers, {:watchers => :new}
               end
               map.project_module :time_tracking do |map|
                 map.permission :log_time, {:timelog => :edit}, :require => :loggedin
                 map.permission :view_time_entries, :timelog => [:details, :report]
                 map.permission :edit_time_entries, {:timelog => [:edit, :destroy]}, :require => :member
                 map.permission :edit_own_time_entries, {:timelog => [:edit, :destroy]}, :require => :loggedin
               end
               map.project_module :news do |map|
                 map.permission :manage_news, {:news => [:new, :edit, :destroy, :destroy_comment]}, :require => :member
                 map.permission :view_news, {:news => [:index, :show]}, :public => true
                 map.permission :comment_news, {:news => :add_comment}
               end
               map.project_module :documents do |map|
                 map.permission :manage_documents, {:documents => [:new, :edit, :destroy, :add_attachment, :destroy_attachment]}, :require => :loggedin
                 map.permission :view_documents, :documents => [:index, :show, :download]
               end
               map.project_module :files do |map|
                 map.permission :manage_files, {:projects => :add_file, :versions => :destroy_file}, :require => :loggedin
                 map.permission :view_files, :projects => :list_files, :versions => :download
               end
               map.project_module :wiki do |map|
                 map.permission :manage_wiki, {:wikis => [:edit, :destroy]}, :require => :member
                 map.permission :rename_wiki_pages, {:wiki => :rename}, :require => :member
                 map.permission :delete_wiki_pages, {:wiki => :destroy}, :require => :member
-                map.permission :view_wiki_pages, :wiki => [:index, :history, :diff, :annotate, :special]
+                map.permission :view_wiki_pages, :wiki => [:index, :special]
+                map.permission :view_wiki_edits, :wiki => [:history, :diff, :annotate]
                 map.permission :edit_wiki_pages, :wiki => [:edit, :preview, :add_attachment, :destroy_attachment]
                 map.permission :protect_wiki_pages, {:wiki => :protect}, :require => :member
               end
               map.project_module :repository do |map|
                 map.permission :manage_repository, {:repositories => [:edit, :destroy]}, :require => :member
                 map.permission :browse_repository, :repositories => [:show, :browse, :entry, :annotate, :changes, :diff, :stats, :graph]
                 map.permission :view_changesets, :repositories => [:show, :revisions, :revision]
                 map.permission :commit_access, {}
               end
               map.project_module :boards do |map|
                 map.permission :manage_boards, {:boards => [:new, :edit, :destroy]}, :require => :member
                 map.permission :view_messages, {:boards => [:index, :show], :messages => [:show]}, :public => true
                 map.permission :add_messages, {:messages => [:new, :reply, :quote]}
                 map.permission :edit_messages, {:messages => :edit}, :require => :member
                 map.permission :delete_messages, {:messages => :destroy}, :require => :member
               end
             end
             Redmine::MenuManager.map :top_menu do |menu|
               menu.push :home, :home_path, :html => { :class => 'home' }
               menu.push :my_page, { :controller => 'my', :action => 'page' }, :html => { :class => 'mypage' }, :if => Proc.new { User.current.logged? }
               menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural, :html => { :class => 'projects' }
               menu.push :administration, { :controller => 'admin', :action => 'index' }, :html => { :class => 'admin' }, :if => Proc.new { User.current.admin? }, :last => true
               menu.push :help, Redmine::Info.help_url, :html => { :class => 'help' }, :last => true
             end
             Redmine::MenuManager.map :account_menu do |menu|
               menu.push :login, :signin_path, :html => { :class => 'login' }, :if => Proc.new { !User.current.logged? }
               menu.push :register, { :controller => 'account', :action => 'register' }, :html => { :class => 'register' }, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
               menu.push :my_account, { :controller => 'my', :action => 'account' }, :html => { :class => 'myaccount' }, :if => Proc.new { User.current.logged? }
               menu.push :logout, :signout_path, :html => { :class => 'logout' }, :if => Proc.new { User.current.logged? }
             end
             Redmine::MenuManager.map :application_menu do |menu|
               # Empty
             end
             Redmine::MenuManager.map :project_menu do |menu|
               menu.push :overview, { :controller => 'projects', :action => 'show' }
               menu.push :activity, { :controller => 'projects', :action => 'activity' }
               menu.push :roadmap, { :controller => 'projects', :action => 'roadmap' },
                           :if => Proc.new { |p| p.versions.any? }
               menu.push :issues, { :controller => 'issues', :action => 'index' }, :param => :project_id, :caption => :label_issue_plural
               menu.push :new_issue, { :controller => 'issues', :action => 'new' }, :param => :project_id, :caption => :label_issue_new,
                           :html => { :accesskey => Redmine::AccessKeys.key_for(:new_issue) }
               menu.push :news, { :controller => 'news', :action => 'index' }, :param => :project_id, :caption => :label_news_plural
               menu.push :documents, { :controller => 'documents', :action => 'index' }, :param => :project_id, :caption => :label_document_plural
               menu.push :wiki, { :controller => 'wiki', :action => 'index', :page => nil },
                           :if => Proc.new { |p| p.wiki && !p.wiki.new_record? }
               menu.push :boards, { :controller => 'boards', :action => 'index', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.boards.any? }, :caption => :label_board_plural
               menu.push :files, { :controller => 'projects', :action => 'list_files' }, :caption => :label_attachment_plural
               menu.push :repository, { :controller => 'repositories', :action => 'show' },
                           :if => Proc.new { |p| p.repository && !p.repository.new_record? }
               menu.push :settings, { :controller => 'projects', :action => 'settings' }, :last => true
             end
             Redmine::Activity.map do |activity|
               activity.register :issues, :class_name => %w(Issue Journal)
               activity.register :changesets
               activity.register :news
               activity.register :documents, :class_name => %w(Document Attachment)
               activity.register :files, :class_name => 'Attachment'
-              activity.register :wiki_pages, :class_name => 'WikiContent::Version', :default => false
+              activity.register :wiki_edits, :class_name => 'WikiContent::Version', :default => false
               activity.register :messages, :default => false
             end

test/fixtures/roles.yml +5 0

             ---
             roles_001:
               name: Manager
               id: 1
               builtin: 0
               permissions: |
                 ---
                 - :edit_project
                 - :manage_members
                 - :manage_versions
                 - :manage_categories
                 - :add_issues
                 - :edit_issues
                 - :manage_issue_relations
                 - :add_issue_notes
                 - :move_issues
                 - :delete_issues
                 - :view_issue_watchers
                 - :add_issue_watchers
                 - :manage_public_queries
                 - :save_queries
                 - :view_gantt
                 - :view_calendar
                 - :log_time
                 - :view_time_entries
                 - :edit_time_entries
                 - :delete_time_entries
                 - :manage_news
                 - :comment_news
                 - :view_documents
                 - :manage_documents
                 - :view_wiki_pages
+                - :view_wiki_edits
                 - :edit_wiki_pages
                 - :protect_wiki_pages
                 - :delete_wiki_pages
                 - :rename_wiki_pages
                 - :add_messages
                 - :edit_messages
                 - :delete_messages
                 - :manage_boards
                 - :view_files
                 - :manage_files
                 - :browse_repository
                 - :view_changesets
               position: 1
             roles_002:
               name: Developer
               id: 2
               builtin: 0
               permissions: |
                 ---
                 - :edit_project
                 - :manage_members
                 - :manage_versions
                 - :manage_categories
                 - :add_issues
                 - :edit_issues
                 - :manage_issue_relations
                 - :add_issue_notes
                 - :move_issues
                 - :delete_issues
                 - :view_issue_watchers
                 - :save_queries
                 - :view_gantt
                 - :view_calendar
                 - :log_time
                 - :view_time_entries
                 - :edit_own_time_entries
                 - :manage_news
                 - :comment_news
                 - :view_documents
                 - :manage_documents
                 - :view_wiki_pages
+                - :view_wiki_edits
                 - :edit_wiki_pages
                 - :protect_wiki_pages
                 - :delete_wiki_pages
                 - :add_messages
                 - :manage_boards
                 - :view_files
                 - :manage_files
                 - :browse_repository
                 - :view_changesets
               position: 2
             roles_003:
               name: Reporter
               id: 3
               builtin: 0
               permissions: |
                 ---
                 - :edit_project
                 - :manage_members
                 - :manage_versions
                 - :manage_categories
                 - :add_issues
                 - :edit_issues
                 - :manage_issue_relations
                 - :add_issue_notes
                 - :move_issues
                 - :view_issue_watchers
                 - :save_queries
                 - :view_gantt
                 - :view_calendar
                 - :log_time
                 - :view_time_entries
                 - :manage_news
                 - :comment_news
                 - :view_documents
                 - :manage_documents
                 - :view_wiki_pages
+                - :view_wiki_edits
                 - :edit_wiki_pages
                 - :delete_wiki_pages
                 - :add_messages
                 - :manage_boards
                 - :view_files
                 - :manage_files
                 - :browse_repository
                 - :view_changesets
               position: 3
             roles_004:
               name: Non member
               id: 4
               builtin: 1
               permissions: |
                 ---
                 - :add_issues
                 - :edit_issues
                 - :manage_issue_relations
                 - :add_issue_notes
                 - :move_issues
                 - :save_queries
                 - :view_gantt
                 - :view_calendar
                 - :log_time
                 - :view_time_entries
                 - :comment_news
                 - :view_documents
                 - :manage_documents
                 - :view_wiki_pages
+                - :view_wiki_edits
                 - :edit_wiki_pages
                 - :add_messages
                 - :view_files
                 - :manage_files
                 - :browse_repository
                 - :view_changesets
               position: 4
             roles_005:
               name: Anonymous
               id: 5
               builtin: 2
               permissions: |
                 ---
                 - :add_issue_notes
                 - :view_gantt
                 - :view_calendar
                 - :view_time_entries
                 - :view_documents
                 - :view_wiki_pages
+                - :view_wiki_edits
                 - :view_files
                 - :browse_repository
                 - :view_changesets
               position: 5
   No newline at end of file

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages