jro_apps/redmine Commit - r7890:c3c2a4afe008

Resourcified documents....

Jean-Philippe Lang -

r7890:c3c2a4afe008

parent child

Context file:

r7890:c3c2a4afe008

Collapse all files

app/controllers/documents_controller.rb +16 -6

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 DocumentsController < ApplicationController
               default_search_scope :documents
               model_object Document
-              before_filter :find_project_by_project_id, :only => [:index, :new]
+              before_filter :find_project_by_project_id, :only => [:index, :new, :create]
-              before_filter :find_model_object, :except => [:index, :new]
+              before_filter :find_model_object, :except => [:index, :new, :create]
-              before_filter :find_project_from_association, :except => [:index, :new]
+              before_filter :find_project_from_association, :except => [:index, :new, :create]
               before_filter :authorize
               helper :attachments
               def index
                 @sort_by = %w(category date title author).include?(params[:sort_by]) ? params[:sort_by] : 'category'
                 documents = @project.documents.find :all, :include => [:attachments, :category]
                 case @sort_by
                 when 'date'
                   @grouped = documents.group_by {|d| d.updated_on.to_date }
                 when 'title'
                   @grouped = documents.group_by {|d| d.title.first.upcase}
                 when 'author'
                   @grouped = documents.select{|d| d.attachments.any?}.group_by {|d| d.attachments.last.author}
                 else
                   @grouped = documents.group_by(&:category)
                 end
                 @document = @project.documents.build
                 render :layout => false if request.xhr?
               end
               def show
                 @attachments = @document.attachments.find(:all, :order => "created_on DESC")
               end
               def new
                 @document = @project.documents.build(params[:document])
+              end
+              def create
+                @document = @project.documents.build(params[:document])
                 if request.post? and @document.save
                   attachments = Attachment.attach_files(@document, params[:attachments])
                   render_attachment_warning_if_needed(@document)
                   flash[:notice] = l(:notice_successful_create)
                   redirect_to :action => 'index', :project_id => @project
+                else
+                  render :action => 'new'
                 end
               end
               def edit
-                @categories = DocumentCategory.active #TODO: use it in the views
+              end
-                if request.post? and @document.update_attributes(params[:document])
+              def update
+                if request.put? and @document.update_attributes(params[:document])
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to :action => 'show', :id => @document
+                else
+                  render :action => 'edit'
                 end
               end
               def destroy
-                @document.destroy
+                @document.destroy if request.delete?
                 redirect_to :controller => 'documents', :action => 'index', :project_id => @project
               end
               def add_attachment
                 attachments = Attachment.attach_files(@document, params[:attachments])
                 render_attachment_warning_if_needed(@document)
                 Mailer.deliver_attachments_added(attachments[:files]) if attachments.present? && attachments[:files].present? && Setting.notified_events.include?('document_added')
                 redirect_to :action => 'show', :id => @document
               end
             end

app/views/documents/_document.html.erb +1 -1

-            <h4><%= link_to h(document.title), :controller => 'documents', :action => 'show', :id => document %></h4>
+            <h4><%= link_to h(document.title), document_path(document) %></h4>
             <p><em><%= format_time(document.updated_on) %></em></p>
             <div class="wiki">
               <%= textilizable(truncate_lines(document.description), :object => document) %>
             </div>

app/views/documents/_form.html.erb +11 -11

@@ -1,15 +1,15
1	<%= error_messages~~_for 'document'~~ %>	1	<%= f.error_messages %>
2	<div class="box">
3	<!--[form:document]-->
4	<p><label for="document_category_id"><%=l(:field_category)%></label>
5	<%= select('document', 'category_id', DocumentCategory.active.collect {\|c\| [c.name, c.id]}) %></p>
6		2
7	<p><label for="document_title"><%=l(:field_title)%> <span class="required">*</span></label>	3	<div class="box tabular">
8	<%= text_field 'document', 'title', :size => 60 %></p>	4	<p><%= f.select :category_id, DocumentCategory.active.collect {\|c\| [c.name, c.id]} %></p>
9		5	<p><%= f.text_field :title, :required => true, :size => 60 %></p>
10	<p><label for="document_description"><%=l(:field_description)%></label>	6	<p><%= f.text_area :description, :cols => 60, :rows => 15, :class => 'wiki-edit' %></p>
11	<%= text_area 'document', 'description', :cols => 60, :rows => 15, :class => 'wiki-edit' %></p>
12	<!--[eoform:document]-->
13	</div>	7	</div>
14		8
15	<%= wikitoolbar_for 'document_description' %>	9	<%= wikitoolbar_for 'document_description' %>
		10
		11	<% if @document.new_record? %>
		12	<div class="box tabular">
		13	<p><label><%=l(:label_attachment_plural)%></label><%= render :partial => 'attachments/form' %></p>
		14	</div>
		15	<% end %>

app/views/documents/edit.html.erb +3 -3

             <h2><%=l(:label_document)%></h2>
-            <% form_tag({:action => 'edit', :id => @document}, :class => "tabular") do %>
+            <% labelled_form_for @document do |f| %>
-              <%= render :partial => 'form' %>
+              <%= render :partial => 'form', :locals => {:f => f} %>
-              <%= submit_tag l(:button_save) %>
+              <p><%= submit_tag l(:button_save) %></p>
             <% end %>

app/views/documents/index.html.erb +8 -11

             <div class="contextual">
-            <%= link_to_if_authorized l(:label_document_new),
+            <%= link_to l(:label_document_new), new_project_document_path(@project), :class => 'icon icon-add',
-                                      {:controller => 'documents', :action => 'new', :project_id => @project},
+                  :onclick => 'Element.show("add-document"); Form.Element.focus("document_title"); return false;' if User.current.allowed_to?(:manage_documents, @project) %>
-                                      :class => 'icon icon-add',
-                                      :onclick => 'Element.show("add-document"); Form.Element.focus("document_title"); return false;' %>
             </div>
             <div id="add-document" style="display:none;">
             <h2><%=l(:label_document_new)%></h2>
-            <% form_tag({:controller => 'documents', :action => 'new', :project_id => @project}, :class => "tabular", :multipart => true) do %>
+            <% labelled_form_for @document, :url => project_documents_path(@project), :html => {:multipart => true} do |f| %>
-            <%= render :partial => 'documents/form' %>
+            <%= render :partial => 'form', :locals => {:f => f} %>
-            <div class="box">
+            <p>
-            <p><label><%=l(:label_attachment_plural)%></label><%= render :partial => 'attachments/form' %></p>
+            	<%= submit_tag l(:button_create) %>
-            </div>
+              <%= link_to l(:button_cancel), "#", :onclick => 'Element.hide("add-document")' %>
-            <%= submit_tag l(:button_create) %>
+            </p>
-            <%= link_to l(:button_cancel), "#", :onclick => 'Element.hide("add-document")' %>
             <% end %>
             </div>
             <h2><%=l(:label_document_plural)%></h2>
             <% if @grouped.empty? %><p class="nodata"><%= l(:label_no_data) %></p><% end %>
             <% @grouped.keys.sort.each do |group| %>
                 <h3><%= group %></h3>
                 <%= render :partial => 'documents/document', :collection => @grouped[group] %>
             <% end %>
             <% content_for :sidebar do %>
                 <h3><%= l(:label_sort_by, '') %></h3>
                 <% form_tag({}, :method => :get) do %>
                 <label><%= radio_button_tag 'sort_by', 'category', (@sort_by == 'category'), :onclick => 'this.form.submit();' %> <%= l(:field_category) %></label><br />
                 <label><%= radio_button_tag 'sort_by', 'date', (@sort_by == 'date'), :onclick => 'this.form.submit();' %> <%= l(:label_date) %></label><br />
                 <label><%= radio_button_tag 'sort_by', 'title', (@sort_by == 'title'), :onclick => 'this.form.submit();' %> <%= l(:field_title) %></label><br />
                 <label><%= radio_button_tag 'sort_by', 'author', (@sort_by == 'author'), :onclick => 'this.form.submit();' %> <%= l(:field_author) %></label>
                 <% end %>
             <% end %>
             <% html_title(l(:label_document_plural)) -%>

app/views/documents/new.html.erb +3 -10

@@ -1,13 +1,6
1	<h2><%=l(:label_document_new)%></h2>	1	<h2><%=l(:label_document_new)%></h2>
2		2
3	<% form_tag({:controller => 'documents', :action => 'new', :project_id => @project}, :class => "tabular", :multipart => true) do %>	3	<% labelled_form_for @document, :url => project_documents_path(@project), :html => {:multipart => true} do \|f\| %>
4	<%= render :partial => '~~documents/~~form' %>	4	<%= render :partial => 'form', :locals => {:f => f} %>
5		5	<p><%= submit_tag l(:button_create) %></p>
6	<div class="box">
7	<p><label><%=l(:label_attachment_plural)%></label><%= render :partial => 'attachments/form' %></p>
8	</div>
9
10	<%= submit_tag l(:button_create) %>
11	<% end %>	6	<% end %>
12
13

app/views/documents/show.html.erb +4 -2

             <div class="contextual">
-            <%= link_to_if_authorized l(:button_edit), {:controller => 'documents', :action => 'edit', :id => @document}, :class => 'icon icon-edit', :accesskey => accesskey(:edit) %>
+            <% if User.current.allowed_to?(:manage_documents, @project) %>
-            <%= link_to_if_authorized l(:button_delete), {:controller => 'documents', :action => 'destroy', :id => @document}, :confirm => l(:text_are_you_sure), :method => :post, :class => 'icon icon-del' %>
+            <%= link_to l(:button_edit), edit_document_path(@document), :class => 'icon icon-edit', :accesskey => accesskey(:edit) %>
+            <%= link_to l(:button_delete), document_path(@document), :confirm => l(:text_are_you_sure), :method => :delete, :class => 'icon icon-del' %>
+            <% end %>
             </div>
             <h2><%=h @document.title %></h2>
             <p><em><%=h @document.category.name %><br />
             <%= format_date @document.created_on %></em></p>
             <div class="wiki">
             <%= textilizable @document.description, :attachments => @document.attachments %>
             </div>
             <h3><%= l(:label_attachment_plural) %></h3>
             <%= link_to_attachments @document %>
             <% if authorize_for('documents', '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 => 'documents', :action => 'add_attachment', :id => @document }, :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) %>
               <% end %>
             <% end %>
             <% html_title @document.title -%>
             <% content_for :header_tags do %>
                 <%= stylesheet_link_tag 'scm' %>
             <% end %>

config/routes.rb +1 -14

             ActionController::Routing::Routes.draw do |map|
               # Add your own custom routes here.
               # The priority is based upon order of creation: first created -> highest priority.
               # Here's a sample route:
               # map.connect 'products/:id', :controller => 'catalog', :action => 'view'
               # Keep in mind you can assign values other than :controller and :action
               map.home '', :controller => 'welcome'
               map.signin 'login', :controller => 'account', :action => 'login'
               map.signout 'logout', :controller => 'account', :action => 'logout'
               map.connect 'roles/workflow/:id/:role_id/:tracker_id', :controller => 'roles', :action => 'workflow'
               map.connect 'help/:ctrl/:page', :controller => 'help'
               map.with_options :controller => 'time_entry_reports', :action => 'report',:conditions => {:method => :get} do |time_report|
                 time_report.connect 'projects/:project_id/issues/:issue_id/time_entries/report'
                 time_report.connect 'projects/:project_id/issues/:issue_id/time_entries/report.:format'
                 time_report.connect 'projects/:project_id/time_entries/report'
                 time_report.connect 'projects/:project_id/time_entries/report.:format'
                 time_report.connect 'time_entries/report'
                 time_report.connect 'time_entries/report.:format'
               end
               map.bulk_edit_time_entry 'time_entries/bulk_edit',
                                :controller => 'timelog', :action => 'bulk_edit', :conditions => { :method => :get }
               map.bulk_update_time_entry 'time_entries/bulk_edit',
                                :controller => 'timelog', :action => 'bulk_update', :conditions => { :method => :post }
               map.time_entries_context_menu '/time_entries/context_menu',
                                :controller => 'context_menus', :action => 'time_entries'
               # TODO: wasteful since this is also nested under issues, projects, and projects/issues
               map.resources :time_entries, :controller => 'timelog'
               map.connect 'projects/:id/wiki', :controller => 'wikis', :action => 'edit', :conditions => {:method => :post}
               map.connect 'projects/:id/wiki/destroy', :controller => 'wikis', :action => 'destroy', :conditions => {:method => :get}
               map.connect 'projects/:id/wiki/destroy', :controller => 'wikis', :action => 'destroy', :conditions => {:method => :post}
               map.with_options :controller => 'messages' do |messages_routes|
                 messages_routes.with_options :conditions => {:method => :get} do |messages_views|
                   messages_views.connect 'boards/:board_id/topics/new', :action => 'new'
                   messages_views.connect 'boards/:board_id/topics/:id', :action => 'show'
                   messages_views.connect 'boards/:board_id/topics/:id/edit', :action => 'edit'
                 end
                 messages_routes.with_options :conditions => {:method => :post} do |messages_actions|
                   messages_actions.connect 'boards/:board_id/topics/new', :action => 'new'
                   messages_actions.connect 'boards/:board_id/topics/:id/replies', :action => 'reply'
                   messages_actions.connect 'boards/:board_id/topics/:id/:action', :action => /edit|destroy/
                 end
               end
               map.with_options :controller => 'boards' do |board_routes|
                 board_routes.with_options :conditions => {:method => :get} do |board_views|
                   board_views.connect 'projects/:project_id/boards', :action => 'index'
                   board_views.connect 'projects/:project_id/boards/new', :action => 'new'
                   board_views.connect 'projects/:project_id/boards/:id', :action => 'show'
                   board_views.connect 'projects/:project_id/boards/:id.:format', :action => 'show'
                   board_views.connect 'projects/:project_id/boards/:id/edit', :action => 'edit'
                 end
                 board_routes.with_options :conditions => {:method => :post} do |board_actions|
                   board_actions.connect 'projects/:project_id/boards', :action => 'new'
                   board_actions.connect 'projects/:project_id/boards/:id/:action', :action => /edit|destroy/
                 end
               end
-              map.with_options :controller => 'documents' do |document_routes|
-                document_routes.with_options :conditions => {:method => :get} do |document_views|
-                  document_views.connect 'projects/:project_id/documents', :action => 'index'
-                  document_views.connect 'projects/:project_id/documents/new', :action => 'new'
-                  document_views.connect 'documents/:id', :action => 'show'
-                  document_views.connect 'documents/:id/edit', :action => 'edit'
-                end
-                document_routes.with_options :conditions => {:method => :post} do |document_actions|
-                  document_actions.connect 'projects/:project_id/documents', :action => 'new'
-                  document_actions.connect 'documents/:id/:action', :action => /destroy|edit/
-                end
-              end
               map.resources :issue_moves, :only => [:new, :create], :path_prefix => '/issues', :as => 'move'
               map.resources :queries, :except => [:show]
               # Misc issue routes. TODO: move into resources
               map.auto_complete_issues '/issues/auto_complete', :controller => 'auto_completes', :action => 'issues'
               map.preview_issue '/issues/preview/:id', :controller => 'previews', :action => 'issue' # TODO: would look nicer as /issues/:id/preview
               map.issues_context_menu '/issues/context_menu', :controller => 'context_menus', :action => 'issues'
               map.issue_changes '/issues/changes', :controller => 'journals', :action => 'index'
               map.bulk_edit_issue 'issues/bulk_edit', :controller => 'issues', :action => 'bulk_edit', :conditions => { :method => :get }
               map.bulk_update_issue 'issues/bulk_edit', :controller => 'issues', :action => 'bulk_update', :conditions => { :method => :post }
               map.quoted_issue '/issues/:id/quoted', :controller => 'journals', :action => 'new', :id => /\d+/, :conditions => { :method => :post }
               map.connect '/issues/:id/destroy', :controller => 'issues', :action => 'destroy', :conditions => { :method => :post } # legacy
               map.with_options :controller => 'gantts', :action => 'show' do |gantts_routes|
                 gantts_routes.connect '/projects/:project_id/issues/gantt'
                 gantts_routes.connect '/projects/:project_id/issues/gantt.:format'
                 gantts_routes.connect '/issues/gantt.:format'
               end
               map.with_options :controller => 'calendars', :action => 'show' do |calendars_routes|
                 calendars_routes.connect '/projects/:project_id/issues/calendar'
                 calendars_routes.connect '/issues/calendar'
               end
               map.with_options :controller => 'reports', :conditions => {:method => :get} do |reports|
                 reports.connect 'projects/:id/issues/report', :action => 'issue_report'
                 reports.connect 'projects/:id/issues/report/:detail', :action => 'issue_report_details'
               end
               # Following two routes conflict with the resources because #index allows POST
               map.connect '/issues', :controller => 'issues', :action => 'index', :conditions => { :method => :post }
               map.connect '/issues/create', :controller => 'issues', :action => 'index', :conditions => { :method => :post }
               map.resources :issues, :member => { :edit => :post }, :collection => {} do |issues|
                 issues.resources :time_entries, :controller => 'timelog'
                 issues.resources :relations, :shallow => true, :controller => 'issue_relations', :only => [:index, :show, :create, :destroy]
               end
               map.resources :issues, :path_prefix => '/projects/:project_id', :collection => { :create => :post } do |issues|
                 issues.resources :time_entries, :controller => 'timelog'
               end
               map.connect 'projects/:id/members/new', :controller => 'members', :action => 'new'
               map.with_options :controller => 'users' do |users|
                 users.connect 'users/:id/edit/:tab', :action => 'edit', :tab => nil, :conditions => {:method => :get}
                 users.with_options :conditions => {:method => :post} do |user_actions|
                   user_actions.connect 'users/:id/memberships', :action => 'edit_membership'
                   user_actions.connect 'users/:id/memberships/:membership_id', :action => 'edit_membership'
                   user_actions.connect 'users/:id/memberships/:membership_id/destroy', :action => 'destroy_membership'
                 end
               end
               map.resources :users, :member => {
                 :edit_membership => :post,
                 :destroy_membership => :post
               }
               # For nice "roadmap" in the url for the index action
               map.connect 'projects/:project_id/roadmap', :controller => 'versions', :action => 'index'
               map.all_news 'news', :controller => 'news', :action => 'index'
               map.formatted_all_news 'news.:format', :controller => 'news', :action => 'index'
               map.preview_news '/news/preview', :controller => 'previews', :action => 'news'
               map.connect 'news/:id/comments', :controller => 'comments', :action => 'create', :conditions => {:method => :post}
               map.connect 'news/:id/comments/:comment_id', :controller => 'comments', :action => 'destroy', :conditions => {:method => :delete}
               map.resources :projects, :member => {
                 :copy => [:get, :post],
                 :settings => :get,
                 :modules => :post,
                 :archive => :post,
                 :unarchive => :post
               } do |project|
                 project.resource :project_enumerations, :as => 'enumerations', :only => [:update, :destroy]
                 project.resources :files, :only => [:index, :new, :create]
                 project.resources :versions, :shallow => true, :collection => {:close_completed => :put}, :member => {:status_by => :post}
                 project.resources :news, :shallow => true
                 project.resources :time_entries, :controller => 'timelog', :path_prefix => 'projects/:project_id'
                 project.resources :queries, :only => [:new, :create]
                 project.resources :issue_categories, :shallow => true
+                project.resources :documents, :shallow => true, :member => {:add_attachment => :post}
                 project.wiki_start_page 'wiki', :controller => 'wiki', :action => 'show', :conditions => {:method => :get}
                 project.wiki_index 'wiki/index', :controller => 'wiki', :action => 'index', :conditions => {:method => :get}
                 project.wiki_diff 'wiki/:id/diff/:version', :controller => 'wiki', :action => 'diff', :version => nil
                 project.wiki_diff 'wiki/:id/diff/:version/vs/:version_from', :controller => 'wiki', :action => 'diff'
                 project.wiki_annotate 'wiki/:id/annotate/:version', :controller => 'wiki', :action => 'annotate'
                 project.resources :wiki, :except => [:new, :create], :member => {
                   :rename => [:get, :post],
                   :history => :get,
                   :preview => :any,
                   :protect => :post,
                   :add_attachment => :post
                 }, :collection => {
                   :export => :get,
                   :date_index => :get
                 }
               end
               # Destroy uses a get request to prompt the user before the actual DELETE request
               map.project_destroy_confirm 'projects/:id/destroy', :controller => 'projects', :action => 'destroy', :conditions => {:method => :get}
               # TODO: port to be part of the resources route(s)
               map.with_options :controller => 'projects' do |project_mapper|
                 project_mapper.with_options :conditions => {:method => :get} do |project_views|
                   project_views.connect 'projects/:id/settings/:tab', :controller => 'projects', :action => 'settings'
                   project_views.connect 'projects/:project_id/issues/:copy_from/copy', :controller => 'issues', :action => 'new'
                 end
               end
               map.with_options :controller => 'activities', :action => 'index', :conditions => {:method => :get} do |activity|
                 activity.connect 'projects/:id/activity'
                 activity.connect 'projects/:id/activity.:format'
                 activity.connect 'activity', :id => nil
                 activity.connect 'activity.:format', :id => nil
               end
               map.with_options :controller => 'repositories' do |repositories|
                 repositories.with_options :conditions => {:method => :get} do |repository_views|
                   repository_views.connect 'projects/:id/repository', :action => 'show'
                   repository_views.connect 'projects/:id/repository/edit', :action => 'edit'
                   repository_views.connect 'projects/:id/repository/statistics', :action => 'stats'
                   repository_views.connect 'projects/:id/repository/revisions', :action => 'revisions'
                   repository_views.connect 'projects/:id/repository/revisions.:format', :action => 'revisions'
                   repository_views.connect 'projects/:id/repository/revisions/:rev', :action => 'revision'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/diff', :action => 'diff'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/diff.:format', :action => 'diff'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/raw/*path', :action => 'entry', :format => 'raw', :requirements => { :rev => /[a-z0-9\.\-_]+/ }
                   repository_views.connect 'projects/:id/repository/revisions/:rev/:action/*path', :requirements => { :rev => /[a-z0-9\.\-_]+/ }
                   repository_views.connect 'projects/:id/repository/raw/*path', :action => 'entry', :format => 'raw'
                   # TODO: why the following route is required?
                   repository_views.connect 'projects/:id/repository/entry/*path', :action => 'entry'
                   repository_views.connect 'projects/:id/repository/:action/*path'
                 end
                 repositories.connect 'projects/:id/repository/:action', :conditions => {:method => :post}
               end
               map.resources :attachments, :only => [:show, :destroy]
               # additional routes for having the file name at the end of url
               map.connect 'attachments/:id/:filename', :controller => 'attachments', :action => 'show', :id => /\d+/, :filename => /.*/
               map.connect 'attachments/download/:id/:filename', :controller => 'attachments', :action => 'download', :id => /\d+/, :filename => /.*/
               map.resources :groups, :member => {:autocomplete_for_user => :get}
               map.group_users 'groups/:id/users', :controller => 'groups', :action => 'add_users', :id => /\d+/, :conditions => {:method => :post}
               map.group_user  'groups/:id/users/:user_id', :controller => 'groups', :action => 'remove_user', :id => /\d+/, :conditions => {:method => :delete}
               map.resources :trackers, :except => :show
               map.resources :issue_statuses, :except => :show, :collection => {:update_issue_done_ratio => :post}
               #left old routes at the bottom for backwards compat
               map.connect 'projects/:project_id/issues/:action', :controller => 'issues'
-              map.connect 'projects/:project_id/documents/:action', :controller => 'documents'
               map.connect 'projects/:project_id/boards/:action/:id', :controller => 'boards'
               map.connect 'boards/:board_id/topics/:action/:id', :controller => 'messages'
               map.connect 'wiki/:id/:page/:action', :page => nil, :controller => 'wiki'
               map.connect 'projects/:project_id/news/:action', :controller => 'news'
               map.connect 'projects/:project_id/timelog/:action/:id', :controller => 'timelog', :project_id => /.+/
               map.with_options :controller => 'repositories' do |omap|
                 omap.repositories_show 'repositories/browse/:id/*path', :action => 'browse'
                 omap.repositories_changes 'repositories/changes/:id/*path', :action => 'changes'
                 omap.repositories_diff 'repositories/diff/:id/*path', :action => 'diff'
                 omap.repositories_entry 'repositories/entry/:id/*path', :action => 'entry'
                 omap.repositories_entry 'repositories/annotate/:id/*path', :action => 'annotate'
                 omap.connect 'repositories/revision/:id/:rev', :action => 'revision'
               end
               map.with_options :controller => 'sys' do |sys|
                 sys.connect 'sys/projects.:format', :action => 'projects', :conditions => {:method => :get}
                 sys.connect 'sys/projects/:id/repository.:format', :action => 'create_project_repository', :conditions => {:method => :post}
               end
               # Install the default route as the lowest priority.
               map.connect ':controller/:action/:id'
               map.connect 'robots.txt', :controller => 'welcome', :action => 'robots'
               # Used for OpenID
               map.root :controller => 'account', :action => 'login'
             end

lib/redmine.rb +1 -1

             require 'redmine/access_control'
             require 'redmine/menu_manager'
             require 'redmine/activity'
             require 'redmine/search'
             require 'redmine/custom_field_format'
             require 'redmine/mime_type'
             require 'redmine/core_ext'
             require 'redmine/themes'
             require 'redmine/hook'
             require 'redmine/plugin'
             require 'redmine/notifiable'
             require 'redmine/wiki_formatting'
             require 'redmine/scm/base'
             begin
               require_library_or_gem 'RMagick' unless Object.const_defined?(:Magick)
             rescue LoadError
               # RMagick is not available
             end
             if RUBY_VERSION < '1.9'
               require 'faster_csv'
             else
               require 'csv'
               FCSV = CSV
             end
             Redmine::Scm::Base.add "Subversion"
             Redmine::Scm::Base.add "Darcs"
             Redmine::Scm::Base.add "Mercurial"
             Redmine::Scm::Base.add "Cvs"
             Redmine::Scm::Base.add "Bazaar"
             Redmine::Scm::Base.add "Git"
             Redmine::Scm::Base.add "Filesystem"
             Redmine::CustomFieldFormat.map do |fields|
               fields.register Redmine::CustomFieldFormat.new('string', :label => :label_string, :order => 1)
               fields.register Redmine::CustomFieldFormat.new('text', :label => :label_text, :order => 2)
               fields.register Redmine::CustomFieldFormat.new('int', :label => :label_integer, :order => 3)
               fields.register Redmine::CustomFieldFormat.new('float', :label => :label_float, :order => 4)
               fields.register Redmine::CustomFieldFormat.new('list', :label => :label_list, :order => 5)
               fields.register Redmine::CustomFieldFormat.new('date', :label => :label_date, :order => 6)
               fields.register Redmine::CustomFieldFormat.new('bool', :label => :label_boolean, :order => 7)
               fields.register Redmine::CustomFieldFormat.new('user', :label => :label_user, :only => %w(Issue TimeEntry Version Project), :edit_as => 'list', :order => 8)
               fields.register Redmine::CustomFieldFormat.new('version', :label => :label_version, :only => %w(Issue TimeEntry Version Project), :edit_as => 'list', :order => 9)
             end
             # Permissions
             Redmine::AccessControl.map do |map|
               map.permission :view_project, {:projects => [:show], :activities => [:index]}, :public => true
               map.permission :search_project, {:search => :index}, :public => true
               map.permission :add_project, {:projects => [:new, :create]}, :require => :loggedin
               map.permission :edit_project, {:projects => [:settings, :edit, :update]}, :require => :member
               map.permission :select_project_modules, {:projects => :modules}, :require => :member
               map.permission :manage_members, {:projects => :settings, :members => [:new, :edit, :destroy, :autocomplete_for_member]}, :require => :member
               map.permission :manage_versions, {:projects => :settings, :versions => [:new, :create, :edit, :update, :close_completed, :destroy]}, :require => :member
               map.permission :add_subprojects, {:projects => [:new, :create]}, :require => :member
               map.project_module :issue_tracking do |map|
                 # Issue categories
                 map.permission :manage_categories, {:projects => :settings, :issue_categories => [:index, :show, :new, :create, :edit, :update, :destroy]}, :require => :member
                 # Issues
                 map.permission :view_issues, {:issues => [:index, :show],
                                               :auto_complete => [:issues],
                                               :context_menus => [:issues],
                                               :versions => [:index, :show, :status_by],
                                               :journals => [:index, :diff],
                                               :queries => :index,
                                               :reports => [:issue_report, :issue_report_details]}
                 map.permission :add_issues, {:issues => [:new, :create, :update_form]}
                 map.permission :edit_issues, {:issues => [:edit, :update, :bulk_edit, :bulk_update, :update_form], :journals => [:new]}
                 map.permission :manage_issue_relations, {:issue_relations => [:index, :show, :create, :destroy]}
                 map.permission :manage_subtasks, {}
                 map.permission :set_issues_private, {}
                 map.permission :set_own_issues_private, {}, :require => :loggedin
                 map.permission :add_issue_notes, {:issues => [:edit, :update], :journals => [:new]}
                 map.permission :edit_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :edit_own_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :move_issues, {:issue_moves => [:new, :create]}, :require => :loggedin
                 map.permission :delete_issues, {:issues => :destroy}, :require => :member
                 # Queries
                 map.permission :manage_public_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 map.permission :save_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :loggedin
                 # Watchers
                 map.permission :view_issue_watchers, {}
                 map.permission :add_issue_watchers, {:watchers => :new}
                 map.permission :delete_issue_watchers, {:watchers => :destroy}
               end
               map.project_module :time_tracking do |map|
                 map.permission :log_time, {:timelog => [:new, :create]}, :require => :loggedin
                 map.permission :view_time_entries, :timelog => [:index, :show], :time_entry_reports => [:report]
                 map.permission :edit_time_entries, {:timelog => [:edit, :update, :destroy, :bulk_edit, :bulk_update]}, :require => :member
                 map.permission :edit_own_time_entries, {:timelog => [:edit, :update, :destroy,:bulk_edit, :bulk_update]}, :require => :loggedin
                 map.permission :manage_project_activities, {:project_enumerations => [:update, :destroy]}, :require => :member
               end
               map.project_module :news do |map|
                 map.permission :manage_news, {:news => [:new, :create, :edit, :update, :destroy], :comments => [:destroy]}, :require => :member
                 map.permission :view_news, {:news => [:index, :show]}, :public => true
                 map.permission :comment_news, {:comments => :create}
               end
               map.project_module :documents do |map|
-                map.permission :manage_documents, {:documents => [:new, :edit, :destroy, :add_attachment]}, :require => :loggedin
+                map.permission :manage_documents, {:documents => [:new, :create, :edit, :update, :destroy, :add_attachment]}, :require => :loggedin
                 map.permission :view_documents, :documents => [:index, :show, :download]
               end
               map.project_module :files do |map|
                 map.permission :manage_files, {:files => [:new, :create]}, :require => :loggedin
                 map.permission :view_files, :files => :index, :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, :show, :special, :date_index]
                 map.permission :export_wiki_pages, :wiki => [:export]
                 map.permission :view_wiki_edits, :wiki => [:history, :diff, :annotate]
                 map.permission :edit_wiki_pages, :wiki => [:edit, :update, :preview, :add_attachment]
                 map.permission :delete_wiki_pages_attachments, {}
                 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
               map.project_module :calendar do |map|
                 map.permission :view_calendar, :calendars => [:show, :update]
               end
               map.project_module :gantt do |map|
                 map.permission :view_gantt, :gantts => [:show, :update]
               end
             end
             Redmine::MenuManager.map :top_menu do |menu|
               menu.push :home, :home_path
               menu.push :my_page, { :controller => 'my', :action => 'page' }, :if => Proc.new { User.current.logged? }
               menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural
               menu.push :administration, { :controller => 'admin', :action => 'index' }, :if => Proc.new { User.current.admin? }, :last => true
               menu.push :help, Redmine::Info.help_url, :last => true
             end
             Redmine::MenuManager.map :account_menu do |menu|
               menu.push :login, :signin_path, :if => Proc.new { !User.current.logged? }
               menu.push :register, { :controller => 'account', :action => 'register' }, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
               menu.push :my_account, { :controller => 'my', :action => 'account' }, :if => Proc.new { User.current.logged? }
               menu.push :logout, :signout_path, :if => Proc.new { User.current.logged? }
             end
             Redmine::MenuManager.map :application_menu do |menu|
               # Empty
             end
             Redmine::MenuManager.map :admin_menu do |menu|
               menu.push :projects, {:controller => 'admin', :action => 'projects'}, :caption => :label_project_plural
               menu.push :users, {:controller => 'users'}, :caption => :label_user_plural
               menu.push :groups, {:controller => 'groups'}, :caption => :label_group_plural
               menu.push :roles, {:controller => 'roles'}, :caption => :label_role_and_permissions
               menu.push :trackers, {:controller => 'trackers'}, :caption => :label_tracker_plural
               menu.push :issue_statuses, {:controller => 'issue_statuses'}, :caption => :label_issue_status_plural,
                         :html => {:class => 'issue_statuses'}
               menu.push :workflows, {:controller => 'workflows', :action => 'edit'}, :caption => :label_workflow
               menu.push :custom_fields, {:controller => 'custom_fields'},  :caption => :label_custom_field_plural,
                         :html => {:class => 'custom_fields'}
               menu.push :enumerations, {:controller => 'enumerations'}
               menu.push :settings, {:controller => 'settings'}
               menu.push :ldap_authentication, {:controller => 'ldap_auth_sources', :action => 'index'},
                         :html => {:class => 'server_authentication'}
               menu.push :plugins, {:controller => 'admin', :action => 'plugins'}, :last => true
               menu.push :info, {:controller => 'admin', :action => 'info'}, :caption => :label_information_plural, :last => true
             end
             Redmine::MenuManager.map :project_menu do |menu|
               menu.push :overview, { :controller => 'projects', :action => 'show' }
               menu.push :activity, { :controller => 'activities', :action => 'index' }
               menu.push :roadmap, { :controller => 'versions', :action => 'index' }, :param => :project_id,
                           :if => Proc.new { |p| p.shared_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 :gantt, { :controller => 'gantts', :action => 'show' }, :param => :project_id, :caption => :label_gantt
               menu.push :calendar, { :controller => 'calendars', :action => 'show' }, :param => :project_id, :caption => :label_calendar
               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 => 'show', :id => nil }, :param => :project_id,
                           :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 => 'files', :action => 'index' }, :caption => :label_file_plural, :param => :project_id
               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
               activity.register :time_entries, :default => false
             end
             Redmine::Search.map do |search|
               search.register :issues
               search.register :news
               search.register :documents
               search.register :changesets
               search.register :wiki_pages
               search.register :messages
               search.register :projects
             end
             Redmine::WikiFormatting.map do |format|
               format.register :textile, Redmine::WikiFormatting::Textile::Formatter, Redmine::WikiFormatting::Textile::Helper
             end
             ActionView::Template.register_template_handler :rsb, Redmine::Views::ApiTemplateHandler

test/functional/documents_controller_test.rb +11 -4

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 File.expand_path('../../test_helper', __FILE__)
             class DocumentsControllerTest < ActionController::TestCase
               fixtures :projects, :users, :roles, :members, :member_roles, :enabled_modules, :documents, :enumerations
               def setup
                 User.current = nil
               end
               def test_index
                 # Sets a default category
                 e = Enumeration.find_by_name('Technical documentation')
                 e.update_attributes(:is_default => true)
                 get :index, :project_id => 'ecookbook'
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:grouped)
                 # Default category selected in the new document form
                 assert_tag :select, :attributes => {:name => 'document[category_id]'},
                                     :child => {:tag => 'option', :attributes => {:selected => 'selected'},
                                                                  :content => 'Technical documentation'}
                 assert ! DocumentCategory.find(16).active?
                 assert_no_tag :option, :attributes => {:value => '16'},
                                        :parent => {:tag => 'select', :attributes => {:id => 'document_category_id'} }
               end
               def test_index_grouped_by_date
                 get :index, :project_id => 'ecookbook', :sort_by => 'date'
                 assert_response :success
                 assert_tag 'h3', :content => '2007-02-12'
               end
               def test_index_grouped_by_title
                 get :index, :project_id => 'ecookbook', :sort_by => 'title'
                 assert_response :success
                 assert_tag 'h3', :content => 'T'
               end
               def test_index_grouped_by_author
                 get :index, :project_id => 'ecookbook', :sort_by => 'author'
                 assert_response :success
                 assert_tag 'h3', :content => 'John Smith'
               end
               def test_index_with_long_description
                 # adds a long description to the first document
                 doc = documents(:documents_001)
                 doc.update_attributes(:description => <<LOREM)
             Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut egestas, mi vehicula varius varius, ipsum massa fermentum orci, eget tristique ante sem vel mi. Nulla facilisi. Donec enim libero, luctus ac sagittis sit amet, vehicula sagittis magna. Duis ultrices molestie ante, eget scelerisque sem iaculis vitae. Etiam fermentum mauris vitae metus pharetra condimentum fermentum est pretium. Proin sollicitudin elementum quam quis pharetra.  Aenean facilisis nunc quis elit volutpat mollis. Aenean eleifend varius euismod. Ut dolor est, congue eget dapibus eget, elementum eu odio. Integer et lectus neque, nec scelerisque nisi. EndOfLineHere
             Vestibulum non velit mi. Aliquam scelerisque libero ut nulla fringilla a sollicitudin magna rhoncus.  Praesent a nunc lorem, ac porttitor eros. Sed ac diam nec neque interdum adipiscing quis quis justo. Donec arcu nunc, fringilla eu dictum at, venenatis ac sem. Vestibulum quis elit urna, ac mattis sapien. Lorem ipsum dolor sit amet, consectetur adipiscing elit.
             LOREM
                 get :index, :project_id => 'ecookbook'
                 assert_response :success
                 assert_template 'index'
                 # should only truncate on new lines to avoid breaking wiki formatting
                 assert_select '.wiki p', :text => (doc.description.split("\n").first + '...')
                 assert_select '.wiki p', :text => Regexp.new(Regexp.escape("EndOfLineHere..."))
               end
               def test_show
                 get :show, :id => 1
                 assert_response :success
                 assert_template 'show'
               end
-              def test_new_with_one_attachment
+              def test_new
+                @request.session[:user_id] = 2
+                get :new, :project_id => 1
+                assert_response :success
+                assert_template 'new'
+              end
+              def test_create_with_one_attachment
                 ActionMailer::Base.deliveries.clear
                 Setting.notified_events << 'document_added'
                 @request.session[:user_id] = 2
                 set_tmp_attachments_directory
-                post :new, :project_id => 'ecookbook',
+                post :create, :project_id => 'ecookbook',
                            :document => { :title => 'DocumentsControllerTest#test_post_new',
                                           :description => 'This is a new document',
                                           :category_id => 2},
                            :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                 assert_redirected_to '/projects/ecookbook/documents'
                 document = Document.find_by_title('DocumentsControllerTest#test_post_new')
                 assert_not_nil document
                 assert_equal Enumeration.find(2), document.category
                 assert_equal 1, document.attachments.size
                 assert_equal 'testfile.txt', document.attachments.first.filename
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_edit
                 @request.session[:user_id] = 2
                 get :edit, :id => 1
                 assert_response :success
                 assert_template 'edit'
               end
               def test_update
                 @request.session[:user_id] = 2
-                post :edit, :id => 1, :document => {:title => 'test_update'}
+                put :update, :id => 1, :document => {:title => 'test_update'}
                 assert_redirected_to '/documents/1'
                 document = Document.find(1)
                 assert_equal 'test_update', document.title
               end
               def test_destroy
                 @request.session[:user_id] = 2
                 assert_difference 'Document.count', -1 do
-                  post :destroy, :id => 1
+                  delete :destroy, :id => 1
                 end
                 assert_redirected_to '/projects/ecookbook/documents'
                 assert_nil Document.find_by_id(1)
               end
               def test_add_attachment
                 @request.session[:user_id] = 2
                 assert_difference 'Attachment.count' do
                   post :add_attachment, :id => 1,
                     :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                 end
                 attachment = Attachment.first(:order => 'id DESC')
                 assert_equal Document.find(1), attachment.container
               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