jro_apps/redmine Commit - r2020:d7718470785c

Pluggable admin menu (patch #2031 by Yuki Sonoda with slight changes)....

Jean-Philippe Lang -

r2020:d7718470785c

parent child

Context file:

r2020:d7718470785c

Collapse all files

app/views/admin/index.rhtml +6 0

             <h2><%=l(:label_administration)%></h2>
             <%= render :partial => 'no_data' if @no_configuration_data %>
             <p class="icon22 icon22-projects">
             <%= link_to l(:label_project_plural), :controller => 'admin', :action => 'projects' %> |
             <%= link_to l(:label_new), :controller => 'projects', :action => 'add' %>
             </p>
             <p class="icon22 icon22-users">
             <%= link_to l(:label_user_plural), :controller => 'users' %> |
             <%= link_to l(:label_new), :controller => 'users', :action => 'add' %>
             </p>
             <p class="icon22 icon22-role">
             <%= link_to l(:label_role_and_permissions), :controller => 'roles' %>
             </p>
             <p class="icon22 icon22-tracker">
             <%= link_to l(:label_tracker_plural), :controller => 'trackers' %> |
             <%= link_to l(:label_issue_status_plural), :controller => 'issue_statuses' %> |
             <%= link_to l(:label_workflow), :controller => 'workflows', :action => 'edit' %>
             </p>
             <p class="icon22 icon22-workflow">
             <%= link_to l(:label_custom_field_plural), :controller => 'custom_fields' %>
             </p>
             <p class="icon22 icon22-options">
             <%= link_to l(:label_enumerations), :controller => 'enumerations' %>
             </p>
             <p class="icon22 icon22-settings">
             <%= link_to l(:label_settings), :controller => 'settings' %>
             </p>
+            <% menu_items_for(:admin_menu) do |item, caption, url, selected| -%>
+              <%= content_tag 'p',
+                link_to(h(caption), item.url, item.html_options),
+                :class => ["icon22", "icon22-#{item.name}"].join(' ') %>
+            <% end -%>
             <p class="icon22 icon22-info">
             <%= link_to l(:label_information_plural), :controller => 'admin', :action => 'info' %>
             </p>
             <% html_title(l(:label_administration)) -%>

lib/redmine.rb +4 0

             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'
             require 'redmine/wiki_formatting'
             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, :special]
                 map.permission :view_wiki_edits, :wiki => [:history, :diff, :annotate]
                 map.permission :edit_wiki_pages, :wiki => [:edit, :preview, :add_attachment]
                 map.permission :delete_wiki_pages_attachments, :wiki => :destroy_attachment
                 map.permission :protect_wiki_pages, {:wiki => :protect}, :require => :member
               end
               map.project_module :repository do |map|
                 map.permission :manage_repository, {:repositories => [:edit, :committers, :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 :edit_own_messages, {:messages => :edit}, :require => :loggedin
                 map.permission :delete_messages, {:messages => :destroy}, :require => :member
                 map.permission :delete_own_messages, {:messages => :destroy}, :require => :loggedin
               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 :admin_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_edits, :class_name => 'WikiContent::Version', :default => false
               activity.register :messages, :default => false
             end
             Redmine::WikiFormatting.map do |format|
               format.register :textile, Redmine::WikiFormatting::Textile::Formatter, Redmine::WikiFormatting::Textile::Helper
             end

lib/redmine/menu_manager.rb +15 -3

             # 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 'gloc'
             module Redmine
               module MenuManager
                 module MenuController
                   def self.included(base)
                     base.extend(ClassMethods)
                   end
                   module ClassMethods
                     @@menu_items = Hash.new {|hash, key| hash[key] = {:default => key, :actions => {}}}
                     mattr_accessor :menu_items
                     # Set the menu item name for a controller or specific actions
                     # Examples:
                     #   * menu_item :tickets # => sets the menu name to :tickets for the whole controller
                     #   * menu_item :tickets, :only => :list # => sets the menu name to :tickets for the 'list' action only
                     #   * menu_item :tickets, :only => [:list, :show] # => sets the menu name to :tickets for 2 actions only
                     #
                     # The default menu item name for a controller is controller_name by default
                     # Eg. the default menu item name for ProjectsController is :projects
                     def menu_item(id, options = {})
                       if actions = options[:only]
                         actions = [] << actions unless actions.is_a?(Array)
                         actions.each {|a| menu_items[controller_name.to_sym][:actions][a.to_sym] = id}
                       else
                         menu_items[controller_name.to_sym][:default] = id
                       end
                     end
                   end
                   def menu_items
                     self.class.menu_items
                   end
                   # Returns the menu item name according to the current action
                   def current_menu_item
                     menu_items[controller_name.to_sym][:actions][action_name.to_sym] ||
                       menu_items[controller_name.to_sym][:default]
                   end
                 end
                 module MenuHelper
                   # Returns the current menu item name
                   def current_menu_item
                     @controller.current_menu_item
                   end
                   # Renders the application main menu
                   def render_main_menu(project)
                     render_menu((project && !project.new_record?) ? :project_menu : :application_menu, project)
                   end
                   def render_menu(menu, project=nil)
                     links = []
+                    menu_items_for(menu, project) do |item, caption, url, selected|
+                      links << content_tag('li',
+                        link_to(h(caption), url, (selected ? item.html_options.merge(:class => 'selected') : item.html_options)))
+                    end
+                    links.empty? ? nil : content_tag('ul', links.join("\n"))
+                  end
+                  def menu_items_for(menu, project=nil)
+                    items = []
                     Redmine::MenuManager.allowed_items(menu, User.current, project).each do |item|
                       unless item.condition && !item.condition.call(project)
                         url = case item.url
                         when Hash
                           project.nil? ? item.url : {item.param => project}.merge(item.url)
                         when Symbol
                           send(item.url)
                         else
                           item.url
                         end
                         caption = item.caption(project)
                         caption = l(caption) if caption.is_a?(Symbol)
-                        links << content_tag('li',
+                        if block_given?
-                          link_to(h(caption), url, (current_menu_item == item.name ? item.html_options.merge(:class => 'selected') : item.html_options)))
+                          yield item, caption, url, (current_menu_item == item.name)
+                        else
+                          items << [item, caption, url, (current_menu_item == item.name)]
+                        end
                       end
                     end
-                    links.empty? ? nil : content_tag('ul', links.join("\n"))
+                    return block_given? ? nil : items
                   end
                 end
                 class << self
                   def map(menu_name)
                     @items ||= {}
                     mapper = Mapper.new(menu_name.to_sym, @items)
                     if block_given?
                       yield mapper
                     else
                       mapper
                     end
                   end
                   def items(menu_name)
                     @items[menu_name.to_sym] || []
                   end
                   def allowed_items(menu_name, user, project)
                     project ? items(menu_name).select {|item| user && user.allowed_to?(item.url, project)} : items(menu_name)
                   end
                 end
                 class Mapper
                   def initialize(menu, items)
                     items[menu] ||= []
                     @menu = menu
                     @menu_items = items[menu]
                   end
                   @@last_items_count = Hash.new {|h,k| h[k] = 0}
                   # Adds an item at the end of the menu. Available options:
                   # * param: the parameter name that is used for the project id (default is :id)
                   # * if: a Proc that is called before rendering the item, the item is displayed only if it returns true
                   # * caption that can be:
                   #   * a localized string Symbol
                   #   * a String
                   #   * a Proc that can take the project as argument
                   # * before, after: specify where the menu item should be inserted (eg. :after => :activity)
                   # * last: menu item will stay at the end (eg. :last => true)
                   # * html_options: a hash of html options that are passed to link_to
                   def push(name, url, options={})
                     options = options.dup
                     # menu item position
                     if before = options.delete(:before)
                       position = @menu_items.collect(&:name).index(before)
                     elsif after = options.delete(:after)
                       position = @menu_items.collect(&:name).index(after)
                       position += 1 unless position.nil?
                     elsif options.delete(:last)
                       position = @menu_items.size
                       @@last_items_count[@menu] += 1
                     end
                     # default position
                     position ||= @menu_items.size - @@last_items_count[@menu]
                     @menu_items.insert(position, MenuItem.new(name, url, options))
                   end
                   # Removes a menu item
                   def delete(name)
                     @menu_items.delete_if {|i| i.name == name}
                   end
                 end
                 class MenuItem
                   include GLoc
                   attr_reader :name, :url, :param, :condition, :html_options
                   def initialize(name, url, options)
                     raise "Invalid option :if for menu item '#{name}'" if options[:if] && !options[:if].respond_to?(:call)
                     raise "Invalid option :html for menu item '#{name}'" if options[:html] && !options[:html].is_a?(Hash)
                     @name = name
                     @url = url
                     @condition = options[:if]
                     @param = options[:param] || :id
                     @caption = options[:caption]
                     @html_options = options[:html] || {}
                   end
                   def caption(project=nil)
                     if @caption.is_a?(Proc)
                       c = @caption.call(project).to_s
                       c = @name.to_s.humanize if c.blank?
                       c
                     else
                       # check if localized string exists on first render (after GLoc strings are loaded)
                       @caption_key ||= (@caption || (l_has_string?("label_#{@name}".to_sym) ? "label_#{@name}".to_sym : @name.to_s.humanize))
                     end
                   end
                 end
               end
             end

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