jro_apps/redmine Commit - r977:86319feef236

Added ApplicationController#attach_files as a common method to attach files in all actions....

Jean-Philippe Lang -

r977:86319feef236

parent child

Context file:

r977:86319feef236

Collapse all files

app/controllers/application.rb +13 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.
             class ApplicationController < ActionController::Base
               before_filter :user_setup, :check_if_login_required, :set_localization
               filter_parameter_logging :password
               REDMINE_SUPPORTED_SCM.each do |scm|
                 require_dependency "repository/#{scm.underscore}"
               end
               def current_role
                 @current_role ||= User.current.role_for_project(@project)
               end
               def user_setup
                 Setting.check_cache
                 if session[:user_id]
                   # existing session
                   User.current = User.find(session[:user_id])
                 elsif cookies[:autologin] && Setting.autologin?
                   # auto-login feature
                   User.current = User.find_by_autologin_key(cookies[:autologin])
                 elsif params[:key] && accept_key_auth_actions.include?(params[:action])
                   # RSS key authentication
                   User.current = User.find_by_rss_key(params[:key])
                 else
                   User.current = User.anonymous
                 end
               end
               # check if login is globally required to access the application
               def check_if_login_required
                 # no check needed if user is already logged in
                 return true if User.current.logged?
                 require_login if Setting.login_required?
               end
               def set_localization
                 lang = begin
                   if !User.current.language.blank? and GLoc.valid_languages.include? User.current.language.to_sym
                     User.current.language
                   elsif request.env['HTTP_ACCEPT_LANGUAGE']
                     accept_lang = parse_qvalues(request.env['HTTP_ACCEPT_LANGUAGE']).first.split('-').first
                     if accept_lang and !accept_lang.empty? and GLoc.valid_languages.include? accept_lang.to_sym
                       accept_lang
                     end
                   end
                 rescue
                   nil
                 end || Setting.default_language
                 set_language_if_valid(lang)
               end
               def require_login
                 if !User.current.logged?
                   store_location
                   redirect_to :controller => "account", :action => "login"
                   return false
                 end
                 true
               end
               def require_admin
                 return unless require_login
                 if !User.current.admin?
                   render_403
                   return false
                 end
                 true
               end
               # Authorize the user for the requested action
               def authorize(ctrl = params[:controller], action = params[:action])
                 allowed = User.current.allowed_to?({:controller => ctrl, :action => action}, @project)
                 allowed ? true : (User.current.logged? ? render_403 : require_login)
               end
               # make sure that the user is a member of the project (or admin) if project is private
               # used as a before_filter for actions that do not require any particular permission on the project
               def check_project_privacy
                 unless @project.active?
                   @project = nil
                   render_404
                   return false
                 end
                 return true if @project.is_public? || User.current.member_of?(@project) || User.current.admin?
                 User.current.logged? ? render_403 : require_login
               end
               # store current uri in session.
               # return to this location by calling redirect_back_or_default
               def store_location
                 session[:return_to_params] = params
               end
               # move to the last store_location call or to the passed default one
               def redirect_back_or_default(default)
                 if session[:return_to_params].nil?
                   redirect_to default
                 else
                   redirect_to session[:return_to_params]
                   session[:return_to_params] = nil
                 end
               end
               def render_403
                 @project = nil
                 render :template => "common/403", :layout => !request.xhr?, :status => 403
                 return false
               end
               def render_404
                 render :template => "common/404", :layout => !request.xhr?, :status => 404
                 return false
               end
               def render_feed(items, options={})
                 @items = items || []
                 @items.sort! {|x,y| y.event_datetime <=> x.event_datetime }
                 @title = options[:title] || Setting.app_title
                 render :template => "common/feed.atom.rxml", :layout => false, :content_type => 'application/atom+xml'
               end
               def self.accept_key_auth(*actions)
                 actions = actions.flatten.map(&:to_s)
                 write_inheritable_attribute('accept_key_auth_actions', actions)
               end
               def accept_key_auth_actions
                 self.class.read_inheritable_attribute('accept_key_auth_actions') || []
               end
+              # TODO: move to model
+              def attach_files(obj, files)
+                attachments = []
+                if files && files.is_a?(Array)
+                  files.each do |file|
+                    next unless file.size > 0
+                    a = Attachment.create(:container => obj, :file => file, :author => User.current)
+                    attachments << a unless a.new_record?
+                  end
+                end
+                attachments
+              end
               # qvalues http header parser
               # code taken from webrick
               def parse_qvalues(value)
                 tmp = []
                 if value
                   parts = value.split(/,\s*/)
                   parts.each {|part|
                     if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
                       val = m[1]
                       q = (m[2] or 1).to_f
                       tmp.push([val, q])
                     end
                   }
                   tmp = tmp.sort_by{|val, q| -q}
                   tmp.collect!{|val, q| val}
                 end
                 return tmp
               end
             end

app/controllers/documents_controller.rb +2 -8

             # 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.
             class DocumentsController < ApplicationController
               layout 'base'
               before_filter :find_project, :authorize
               def show
                 @attachments = @document.attachments.find(:all, :order => "created_on DESC")
               end
               def edit
                 @categories = Enumeration::get_values('DCAT')
                 if request.post? and @document.update_attributes(params[:document])
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to :action => 'show', :id => @document
                 end
               end
               def destroy
                 @document.destroy
                 redirect_to :controller => 'projects', :action => 'list_documents', :id => @project
               end
               def download
                 @attachment = @document.attachments.find(params[:attachment_id])
                 @attachment.increment_download
                 send_file @attachment.diskfile, :filename => @attachment.filename, :type => @attachment.content_type
               rescue
                 render_404
               end
               def add_attachment
-                # Save the attachments
+                attachments = attach_files(@document, params[:attachments])
-                @attachments = []
+                Mailer.deliver_attachments_added(attachments) if !attachments.empty? && Setting.notified_events.include?('document_added')
-                params[:attachments].each { |file|
-                  next unless file.size > 0
-                  a = Attachment.create(:container => @document, :file => file, :author => User.current)
-                  @attachments << a unless a.new_record?
-                } if params[:attachments] and params[:attachments].is_a? Array
-                Mailer.deliver_attachments_added(@attachments) if !@attachments.empty? && Setting.notified_events.include?('document_added')
                 redirect_to :action => 'show', :id => @document
               end
               def destroy_attachment
                 @document.attachments.find(params[:attachment_id]).destroy
                 redirect_to :action => 'show', :id => @document
               end
             private
               def find_project
                 @document = Document.find(params[:id])
                 @project = @document.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/controllers/issues_controller.rb +4 -16

             # 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.
             class IssuesController < ApplicationController
               layout 'base'
               before_filter :find_project, :authorize, :except => [:index, :changes, :preview]
               before_filter :find_optional_project, :only => [:index, :changes]
               accept_key_auth :index, :changes
               cache_sweeper :issue_sweeper, :only => [ :edit, :change_status, :destroy ]
               helper :projects
               include ProjectsHelper
               helper :custom_fields
               include CustomFieldsHelper
               helper :ifpdf
               include IfpdfHelper
               helper :issue_relations
               include IssueRelationsHelper
               helper :watchers
               include WatchersHelper
               helper :attachments
               include AttachmentsHelper
               helper :queries
               helper :sort
               include SortHelper
               include IssuesHelper
               def index
                 sort_init "#{Issue.table_name}.id", "desc"
                 sort_update
                 retrieve_query
                 if @query.valid?
                   limit = %w(pdf csv).include?(params[:format]) ? Setting.issues_export_limit.to_i : 25
                   @issue_count = Issue.count(:include => [:status, :project], :conditions => @query.statement)
                   @issue_pages = Paginator.new self, @issue_count, limit, params['page']
                   @issues = Issue.find :all, :order => sort_clause,
                                        :include => [ :assigned_to, :status, :tracker, :project, :priority, :category, :fixed_version ],
                                        :conditions => @query.statement,
                                        :limit  =>  limit,
                                        :offset =>  @issue_pages.current.offset
                   respond_to do |format|
                     format.html { render :template => 'issues/index.rhtml', :layout => !request.xhr? }
                     format.atom { render_feed(@issues, :title => l(:label_issue_plural)) }
                     format.csv  { send_data(issues_to_csv(@issues, @project).read, :type => 'text/csv; header=present', :filename => 'export.csv') }
                     format.pdf  { send_data(render(:template => 'issues/index.rfpdf', :layout => false), :type => 'application/pdf', :filename => 'export.pdf') }
                   end
                 else
                   # Send html if the query is not valid
                   render(:template => 'issues/index.rhtml', :layout => !request.xhr?)
                 end
               end
               def changes
                 sort_init "#{Issue.table_name}.id", "desc"
                 sort_update
                 retrieve_query
                 if @query.valid?
                   @changes = Journal.find :all, :include => [ :details, :user, {:issue => [:project, :author, :tracker, :status]} ],
                                                  :conditions => @query.statement,
                                                  :limit => 25,
                                                  :order => "#{Journal.table_name}.created_on DESC"
                 end
                 @title = (@project ? @project.name : Setting.app_title) + ": " + (@query.new_record? ? l(:label_changes_details) : @query.name)
                 render :layout => false, :content_type => 'application/atom+xml'
               end
               def show
                 @custom_values = @issue.custom_values.find(:all, :include => :custom_field, :order => "#{CustomField.table_name}.position")
                 @journals = @issue.journals.find(:all, :include => [:user, :details], :order => "#{Journal.table_name}.created_on ASC")
                 @status_options = @issue.status.find_new_statuses_allowed_to(User.current.role_for_project(@project), @issue.tracker)
                 respond_to do |format|
                   format.html { render :template => 'issues/show.rhtml' }
                   format.pdf  { send_data(render(:template => 'issues/show.rfpdf', :layout => false), :type => 'application/pdf', :filename => "#{@project.identifier}-#{@issue.id}.pdf") }
                 end
               end
               def edit
                 @priorities = Enumeration::get_values('IPRI')
                 @custom_values = []
                 if request.get?
                   @custom_values = @project.custom_fields_for_issues(@issue.tracker).collect { |x| @issue.custom_values.find_by_custom_field_id(x.id) || CustomValue.new(:custom_field => x, :customized => @issue) }
                 else
                   begin
                     @issue.init_journal(User.current)
                     # Retrieve custom fields and values
                     if params["custom_fields"]
                       @custom_values = @project.custom_fields_for_issues(@issue.tracker).collect { |x| CustomValue.new(:custom_field => x, :customized => @issue, :value => params["custom_fields"][x.id.to_s]) }
                       @issue.custom_values = @custom_values
                     end
                     @issue.attributes = params[:issue]
                     if @issue.save
                       flash[:notice] = l(:notice_successful_update)
                       redirect_to(params[:back_to] || {:action => 'show', :id => @issue})
                     end
                   rescue ActiveRecord::StaleObjectError
                     # Optimistic locking exception
                     flash[:error] = l(:notice_locking_conflict)
                   end
                 end
               end
               def add_note
                 journal = @issue.init_journal(User.current, params[:notes])
-                params[:attachments].each { |file|
+                attachments = attach_files(@issue, params[:attachments])
-                  next unless file.size > 0
+                attachments.each {|a| journal.details << JournalDetail.new(:property => 'attachment', :prop_key => a.id, :value => a.filename)}
-                  a = Attachment.create(:container => @issue, :file => file, :author => User.current)
-                  journal.details << JournalDetail.new(:property => 'attachment',
-                                                       :prop_key => a.id,
-                                                       :value => a.filename) unless a.new_record?
-                } if params[:attachments] and params[:attachments].is_a? Array
                 if journal.save
                   flash[:notice] = l(:notice_successful_update)
                   Mailer.deliver_issue_edit(journal) if Setting.notified_events.include?('issue_updated')
                   redirect_to :action => 'show', :id => @issue
                   return
                 end
                 show
               end
               def change_status
                 @status_options = @issue.status.find_new_statuses_allowed_to(User.current.role_for_project(@project), @issue.tracker)
                 @new_status = IssueStatus.find(params[:new_status_id])
                 if params[:confirm]
                   begin
                     journal = @issue.init_journal(User.current, params[:notes])
                     @issue.status = @new_status
                     if @issue.update_attributes(params[:issue])
-                      # Save attachments
+                      attachments = attach_files(@issue, params[:attachments])
-                      params[:attachments].each { |file|
+                      attachments.each {|a| journal.details << JournalDetail.new(:property => 'attachment', :prop_key => a.id, :value => a.filename)}
-                        next unless file.size > 0
-                        a = Attachment.create(:container => @issue, :file => file, :author => User.current)
-                        journal.details << JournalDetail.new(:property => 'attachment',
-                                                             :prop_key => a.id,
-                                                             :value => a.filename) unless a.new_record?
-                      } if params[:attachments] and params[:attachments].is_a? Array
                       # Log time
                       if current_role.allowed_to?(:log_time)
                         @time_entry ||= TimeEntry.new(:project => @project, :issue => @issue, :user => User.current, :spent_on => Date.today)
                         @time_entry.attributes = params[:time_entry]
                         @time_entry.save
                       end
                       flash[:notice] = l(:notice_successful_update)
                       Mailer.deliver_issue_edit(journal) if Setting.notified_events.include?('issue_updated')
                       redirect_to :action => 'show', :id => @issue
                     end
                   rescue ActiveRecord::StaleObjectError
                     # Optimistic locking exception
                     flash[:error] = l(:notice_locking_conflict)
                   end
                 end
                 @assignable_to = @project.members.find(:all, :include => :user).collect{ |m| m.user }
                 @activities = Enumeration::get_values('ACTI')
               end
               def destroy
                 @issue.destroy
                 redirect_to :action => 'index', :project_id => @project
               end
               def destroy_attachment
                 a = @issue.attachments.find(params[:attachment_id])
                 a.destroy
                 journal = @issue.init_journal(User.current)
                 journal.details << JournalDetail.new(:property => 'attachment',
                                                      :prop_key => a.id,
                                                      :old_value => a.filename)
                 journal.save
                 redirect_to :action => 'show', :id => @issue
               end
               def context_menu
                 @priorities = Enumeration.get_values('IPRI').reverse
                 @statuses = IssueStatus.find(:all, :order => 'position')
                 @allowed_statuses = @issue.status.find_new_statuses_allowed_to(User.current.role_for_project(@project), @issue.tracker)
                 @assignables = @issue.assignable_users
                 @assignables << @issue.assigned_to if @issue.assigned_to && !@assignables.include?(@issue.assigned_to)
                 @can = {:edit => User.current.allowed_to?(:edit_issues, @project),
                         :change_status => User.current.allowed_to?(:change_issue_status, @project),
                         :add => User.current.allowed_to?(:add_issues, @project),
                         :move => User.current.allowed_to?(:move_issues, @project),
                         :copy => (@project.trackers.include?(@issue.tracker) && User.current.allowed_to?(:add_issues, @project)),
                         :delete => User.current.allowed_to?(:delete_issues, @project)}
                 render :layout => false
               end
               def preview
                 issue = Issue.find_by_id(params[:id])
                 @attachements = issue.attachments if issue
                 @text = params[:issue][:description]
                 render :partial => 'common/preview'
               end
             private
               def find_project
                 @issue = Issue.find(params[:id], :include => [:project, :tracker, :status, :author, :priority, :category])
                 @project = @issue.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_optional_project
                 return true unless params[:project_id]
                 @project = Project.find(params[:project_id])
                 authorize
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Retrieve query from session or build a new query
               def retrieve_query
                 if params[:query_id]
                   @query = Query.find(params[:query_id], :conditions => {:project_id => (@project ? @project.id : nil)})
                   session[:query] = @query
                 else
                   if params[:set_filter] or !session[:query] or session[:query].project != @project
                     # Give it a name, required to be valid
                     @query = Query.new(:name => "_")
                     @query.project = @project
                     if params[:fields] and params[:fields].is_a? Array
                       params[:fields].each do |field|
                         @query.add_filter(field, params[:operators][field], params[:values][field])
                       end
                     else
                       @query.available_filters.keys.each do |field|
                         @query.add_short_filter(field, params[field]) if params[field]
                       end
                     end
                     session[:query] = @query
                   else
                     @query = session[:query]
                   end
                 end
               end
             end

app/controllers/messages_controller.rb +3 -9

             # 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.
             class MessagesController < ApplicationController
               layout 'base'
               before_filter :find_board, :only => :new
               before_filter :find_message, :except => :new
               before_filter :authorize
               verify :method => :post, :only => [ :reply, :destroy ], :redirect_to => { :action => :show }
               helper :attachments
               include AttachmentsHelper
               # Show a topic and its replies
               def show
                 @reply = Message.new(:subject => "RE: #{@message.subject}")
                 render :action => "show", :layout => false if request.xhr?
               end
               # Create a new topic
               def new
                 @message = Message.new(params[:message])
                 @message.author = User.current
                 @message.board = @board
                 if params[:message] && User.current.allowed_to?(:edit_messages, @project)
                   @message.locked = params[:message]['locked']
                   @message.sticky = params[:message]['sticky']
                 end
                 if request.post? && @message.save
-                  params[:attachments].each { |file|
+                  attach_files(@message, params[:attachments])
-                    Attachment.create(:container => @message, :file => file, :author => User.current) if file.size > 0
-                  } if params[:attachments] and params[:attachments].is_a? Array
                   redirect_to :action => 'show', :id => @message
                 end
               end
               # Reply to a topic
               def reply
                 @reply = Message.new(params[:reply])
                 @reply.author = User.current
                 @reply.board = @board
                 @topic.children << @reply
                 if !@reply.new_record?
-                  params[:attachments].each { |file|
+                  attach_files(@reply, params[:attachments])
-                    Attachment.create(:container => @reply, :file => file, :author => User.current) if file.size > 0
-                  } if params[:attachments] and params[:attachments].is_a? Array
                 end
                 redirect_to :action => 'show', :id => @topic
               end
               # Edit a message
               def edit
                 if params[:message] && User.current.allowed_to?(:edit_messages, @project)
                   @message.locked = params[:message]['locked']
                   @message.sticky = params[:message]['sticky']
                 end
                 if request.post? && @message.update_attributes(params[:message])
-                  params[:attachments].each { |file|
+                  attach_files(@message, params[:attachments])
-                    Attachment.create(:container => @message, :file => file, :author => User.current) if file.size > 0
-                  } if params[:attachments] and params[:attachments].is_a? Array
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to :action => 'show', :id => @topic
                 end
               end
               # Delete a messages
               def destroy
                 @message.destroy
                 redirect_to @message.parent.nil? ?
                   { :controller => 'boards', :action => 'show', :project_id => @project, :id => @board } :
                   { :action => 'show', :id => @message.parent }
               end
             private
               def find_message
                 find_board
                 @message = @board.messages.find(params[:id], :include => :parent)
                 @topic = @message.root
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_board
                 @board = Board.find(params[:board_id], :include => :project)
                 @project = @board.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/controllers/projects_controller.rb +4 -16

             # 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.
             class ProjectsController < ApplicationController
               layout 'base'
               before_filter :find_project, :except => [ :index, :list, :add ]
               before_filter :authorize, :except => [ :index, :list, :add, :archive, :unarchive, :destroy ]
               before_filter :require_admin, :only => [ :add, :archive, :unarchive, :destroy ]
               accept_key_auth :activity, :calendar
               cache_sweeper :project_sweeper, :only => [ :add, :edit, :archive, :unarchive, :destroy ]
               cache_sweeper :issue_sweeper, :only => [ :add_issue ]
               cache_sweeper :version_sweeper, :only => [ :add_version ]
               helper :sort
               include SortHelper
               helper :custom_fields
               include CustomFieldsHelper
               helper :ifpdf
               include IfpdfHelper
               helper :issues
               helper IssuesHelper
               helper :queries
               include QueriesHelper
               helper :repositories
               include RepositoriesHelper
               include ProjectsHelper
               def index
                 list
                 render :action => 'list' unless request.xhr?
               end
               # Lists visible projects
               def list
                 projects = Project.find :all,
                                         :conditions => Project.visible_by(User.current),
                                         :include => :parent
                 @project_tree = projects.group_by {|p| p.parent || p}
                 @project_tree.each_key {|p| @project_tree[p] -= [p]}
               end
               # Add a new project
               def add
                 @custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
                 @trackers = Tracker.all
                 @root_projects = Project.find(:all,
                                               :conditions => "parent_id IS NULL AND status = #{Project::STATUS_ACTIVE}",
                                               :order => 'name')
                 @project = Project.new(params[:project])
                 @project.enabled_module_names = Redmine::AccessControl.available_project_modules
                 if request.get?
                   @custom_values = ProjectCustomField.find(:all, :order => "#{CustomField.table_name}.position").collect { |x| CustomValue.new(:custom_field => x, :customized => @project) }
                   @project.trackers = Tracker.all
                 else
                   @project.custom_fields = CustomField.find(params[:custom_field_ids]) if params[:custom_field_ids]
                   @custom_values = ProjectCustomField.find(:all, :order => "#{CustomField.table_name}.position").collect { |x| CustomValue.new(:custom_field => x, :customized => @project, :value => (params[:custom_fields] ? params["custom_fields"][x.id.to_s] : nil)) }
                   @project.custom_values = @custom_values
                   if @project.save
                     @project.enabled_module_names = params[:enabled_modules]
                     flash[:notice] = l(:notice_successful_create)
                     redirect_to :controller => 'admin', :action => 'projects'
             	  end
                 end
               end
               # Show @project
               def show
                 @custom_values = @project.custom_values.find(:all, :include => :custom_field, :order => "#{CustomField.table_name}.position")
                 @members_by_role = @project.members.find(:all, :include => [:user, :role], :order => 'position').group_by {|m| m.role}
                 @subprojects = @project.active_children
                 @news = @project.news.find(:all, :limit => 5, :include => [ :author, :project ], :order => "#{News.table_name}.created_on DESC")
                 @trackers = @project.trackers
                 @open_issues_by_tracker = Issue.count(:group => :tracker, :joins => "INNER JOIN #{IssueStatus.table_name} ON #{IssueStatus.table_name}.id = #{Issue.table_name}.status_id", :conditions => ["project_id=? and #{IssueStatus.table_name}.is_closed=?", @project.id, false])
                 @total_issues_by_tracker = Issue.count(:group => :tracker, :conditions => ["project_id=?", @project.id])
                 @total_hours = @project.time_entries.sum(:hours)
                 @key = User.current.rss_key
               end
               def settings
                 @root_projects = Project.find(:all,
                                               :conditions => ["parent_id IS NULL AND status = #{Project::STATUS_ACTIVE} AND id <> ?", @project.id],
                                               :order => 'name')
                 @custom_fields = IssueCustomField.find(:all)
                 @issue_category ||= IssueCategory.new
                 @member ||= @project.members.new
                 @trackers = Tracker.all
                 @custom_values ||= ProjectCustomField.find(:all, :order => "#{CustomField.table_name}.position").collect { |x| @project.custom_values.find_by_custom_field_id(x.id) || CustomValue.new(:custom_field => x) }
                 @repository ||= @project.repository
                 @wiki ||= @project.wiki
               end
               # Edit @project
               def edit
                 if request.post?
                   @project.custom_fields = IssueCustomField.find(params[:custom_field_ids]) if params[:custom_field_ids]
                   if params[:custom_fields]
                     @custom_values = ProjectCustomField.find(:all, :order => "#{CustomField.table_name}.position").collect { |x| CustomValue.new(:custom_field => x, :customized => @project, :value => params["custom_fields"][x.id.to_s]) }
                     @project.custom_values = @custom_values
                   end
                   @project.attributes = params[:project]
                   if @project.save
                     flash[:notice] = l(:notice_successful_update)
                     redirect_to :action => 'settings', :id => @project
                   else
                     settings
                     render :action => 'settings'
                   end
                 end
               end
               def modules
                 @project.enabled_module_names = params[:enabled_modules]
                 redirect_to :action => 'settings', :id => @project, :tab => 'modules'
               end
               def archive
                 @project.archive if request.post? && @project.active?
                 redirect_to :controller => 'admin', :action => 'projects'
               end
               def unarchive
                 @project.unarchive if request.post? && !@project.active?
                 redirect_to :controller => 'admin', :action => 'projects'
               end
               # Delete @project
               def destroy
                 @project_to_destroy = @project
                 if request.post? and params[:confirm]
                   @project_to_destroy.destroy
                   redirect_to :controller => 'admin', :action => 'projects'
                 end
                 # hide project in layout
                 @project = nil
               end
               # Add a new issue category to @project
               def add_issue_category
                 @category = @project.issue_categories.build(params[:category])
                 if request.post? and @category.save
               	  respond_to do |format|
                     format.html do
                       flash[:notice] = l(:notice_successful_create)
                       redirect_to :action => 'settings', :tab => 'categories', :id => @project
                     end
                     format.js do
                       # IE doesn't support the replace_html rjs method for select box options
                       render(:update) {|page| page.replace "issue_category_id",
                         content_tag('select', '<option></option>' + options_from_collection_for_select(@project.issue_categories, 'id', 'name', @category.id), :id => 'issue_category_id', :name => 'issue[category_id]')
                       }
                     end
                   end
                 end
               end
               # Add a new version to @project
               def add_version
               	@version = @project.versions.build(params[:version])
               	if request.post? and @version.save
               	  flash[:notice] = l(:notice_successful_create)
                   redirect_to :action => 'settings', :tab => 'versions', :id => @project
               	end
               end
               # Add a new document to @project
               def add_document
                 @document = @project.documents.build(params[:document])
                 if request.post? and @document.save
-                  # Save the attachments
+                  attach_files(@document, params[:attachments])
-                  params[:attachments].each { |a|
-                    Attachment.create(:container => @document, :file => a, :author => User.current) unless a.size == 0
-                  } if params[:attachments] and params[:attachments].is_a? Array
                   flash[:notice] = l(:notice_successful_create)
                   Mailer.deliver_document_added(@document) if Setting.notified_events.include?('document_added')
                   redirect_to :action => 'list_documents', :id => @project
                 end
               end
               # Show documents list of @project
               def list_documents
                 @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.created_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
                 render :layout => false if request.xhr?
               end
               # Add a new issue to @project
               # The new issue will be created from an existing one if copy_from parameter is given
               def add_issue
                 @issue = params[:copy_from] ? Issue.new.copy_from(params[:copy_from]) : Issue.new(params[:issue])
                 @issue.project = @project
                 @issue.author = User.current
                 @issue.tracker ||= @project.trackers.find(params[:tracker_id])
                 default_status = IssueStatus.default
                 unless default_status
                   flash.now[:error] = 'No default issue status is defined. Please check your configuration (Go to "Administration -> Issue statuses").'
                   render :nothing => true, :layout => true
                   return
                 end
                 @issue.status = default_status
                 @allowed_statuses = ([default_status] + default_status.find_new_statuses_allowed_to(User.current.role_for_project(@project), @issue.tracker))
                 if request.get?
                   @issue.start_date ||= Date.today
                   @custom_values = @issue.custom_values.empty? ?
                     @project.custom_fields_for_issues(@issue.tracker).collect { |x| CustomValue.new(:custom_field => x, :customized => @issue) } :
                     @issue.custom_values
                 else
                   requested_status = IssueStatus.find_by_id(params[:issue][:status_id])
                   # Check that the user is allowed to apply the requested status
                   @issue.status = (@allowed_statuses.include? requested_status) ? requested_status : default_status
                   @custom_values = @project.custom_fields_for_issues(@issue.tracker).collect { |x| CustomValue.new(:custom_field => x, :customized => @issue, :value => params["custom_fields"][x.id.to_s]) }
                   @issue.custom_values = @custom_values
                   if @issue.save
-                    if params[:attachments] && params[:attachments].is_a?(Array)
+                    attach_files(@issue, params[:attachments])
-                      # Save attachments
-                      params[:attachments].each {|a| Attachment.create(:container => @issue, :file => a, :author => User.current) unless a.size == 0}
-                    end
                     flash[:notice] = l(:notice_successful_create)
                     Mailer.deliver_issue_add(@issue) if Setting.notified_events.include?('issue_added')
                     redirect_to :controller => 'issues', :action => 'index', :project_id => @project
                     return
                   end
                 end
                 @priorities = Enumeration::get_values('IPRI')
               end
               # Bulk edit issues
               def bulk_edit_issues
                 if request.post?
                   status = params[:status_id].blank? ? nil : IssueStatus.find_by_id(params[:status_id])
                   priority = params[:priority_id].blank? ? nil : Enumeration.find_by_id(params[:priority_id])
                   assigned_to = params[:assigned_to_id].blank? ? nil : User.find_by_id(params[:assigned_to_id])
                   category = params[:category_id].blank? ? nil : @project.issue_categories.find_by_id(params[:category_id])
                   fixed_version = params[:fixed_version_id].blank? ? nil : @project.versions.find_by_id(params[:fixed_version_id])
                   issues = @project.issues.find_all_by_id(params[:issue_ids])
                   unsaved_issue_ids = []
                   issues.each do |issue|
                     journal = issue.init_journal(User.current, params[:notes])
                     issue.priority = priority if priority
                     issue.assigned_to = assigned_to if assigned_to || params[:assigned_to_id] == 'none'
                     issue.category = category if category
                     issue.fixed_version = fixed_version if fixed_version
                     issue.start_date = params[:start_date] unless params[:start_date].blank?
                     issue.due_date = params[:due_date] unless params[:due_date].blank?
                     issue.done_ratio = params[:done_ratio] unless params[:done_ratio].blank?
                     # Don't save any change to the issue if the user is not authorized to apply the requested status
                     if (status.nil? || (issue.status.new_status_allowed_to?(status, current_role, issue.tracker) && issue.status = status)) && issue.save
                       # Send notification for each issue (if changed)
                       Mailer.deliver_issue_edit(journal) if journal.details.any? && Setting.notified_events.include?('issue_updated')
                     else
                       # Keep unsaved issue ids to display them in flash error
                       unsaved_issue_ids << issue.id
                     end
                   end
                   if unsaved_issue_ids.empty?
                     flash[:notice] = l(:notice_successful_update) unless issues.empty?
                   else
                     flash[:error] = l(:notice_failed_to_save_issues, unsaved_issue_ids.size, issues.size, '#' + unsaved_issue_ids.join(', #'))
                   end
                   redirect_to :controller => 'issues', :action => 'index', :project_id => @project
                   return
                 end
                 if current_role && User.current.allowed_to?(:change_issue_status, @project)
                   # Find potential statuses the user could be allowed to switch issues to
                   @available_statuses = Workflow.find(:all, :include => :new_status,
                                                             :conditions => {:role_id => current_role.id}).collect(&:new_status).compact.uniq
                 end
                 render :update do |page|
                   page.hide 'query_form'
                   page.replace_html  'bulk-edit', :partial => 'issues/bulk_edit_form'
                 end
               end
               def move_issues
                 @issues = @project.issues.find(params[:issue_ids]) if params[:issue_ids]
                 redirect_to :controller => 'issues', :action => 'index', :project_id => @project and return unless @issues
                 @projects = []
                 # find projects to which the user is allowed to move the issue
                 if User.current.admin?
                   # admin is allowed to move issues to any active (visible) project
                   @projects = Project.find(:all, :conditions => Project.visible_by(User.current), :order => 'name')
                 else
                   User.current.memberships.each {|m| @projects << m.project if m.role.allowed_to?(:move_issues)}
                 end
                 @target_project = @projects.detect {|p| p.id.to_s == params[:new_project_id]} if params[:new_project_id]
                 @target_project ||= @project
                 @trackers = @target_project.trackers
                 if request.post?
                   new_tracker = params[:new_tracker_id].blank? ? nil : @target_project.trackers.find_by_id(params[:new_tracker_id])
                   unsaved_issue_ids = []
                   @issues.each do |issue|
                     unsaved_issue_ids << issue.id unless issue.move_to(@target_project, new_tracker)
                   end
                   if unsaved_issue_ids.empty?
                     flash[:notice] = l(:notice_successful_update) unless @issues.empty?
                   else
                     flash[:error] = l(:notice_failed_to_save_issues, unsaved_issue_ids.size, @issues.size, '#' + unsaved_issue_ids.join(', #'))
                   end
                   redirect_to :controller => 'issues', :action => 'index', :project_id => @project
                   return
                 end
                 render :layout => false if request.xhr?
               end
               # Add a news to @project
               def add_news
                 @news = News.new(:project => @project, :author => User.current)
                 if request.post?
                   @news.attributes = params[:news]
                   if @news.save
                     flash[:notice] = l(:notice_successful_create)
                     Mailer.deliver_news_added(@news) if Setting.notified_events.include?('news_added')
                     redirect_to :controller => 'news', :action => 'index', :project_id => @project
                   end
                 end
               end
               def add_file
                 if request.post?
                   @version = @project.versions.find_by_id(params[:version_id])
-                  # Save the attachments
+                  attachments = attach_files(@issue, params[:attachments])
-                  @attachments = []
+                  Mailer.deliver_attachments_added(attachments) if !attachments.empty? && Setting.notified_events.include?('file_added')
-                  params[:attachments].each { |file|
-                    next unless file.size > 0
-                    a = Attachment.create(:container => @version, :file => file, :author => User.current)
-                    @attachments << a unless a.new_record?
-                  } if params[:attachments] and params[:attachments].is_a? Array
-                  Mailer.deliver_attachments_added(@attachments) if !@attachments.empty? && Setting.notified_events.include?('file_added')
                   redirect_to :controller => 'projects', :action => 'list_files', :id => @project
                 end
                 @versions = @project.versions.sort
               end
               def list_files
                 @versions = @project.versions.sort
               end
               # Show changelog for @project
               def changelog
                 @trackers = @project.trackers.find(:all, :conditions => ["is_in_chlog=?", true], :order => 'position')
                 retrieve_selected_tracker_ids(@trackers)
                 @versions = @project.versions.sort
               end
               def roadmap
                 @trackers = @project.trackers.find(:all, :conditions => ["is_in_roadmap=?", true])
                 retrieve_selected_tracker_ids(@trackers)
                 @versions = @project.versions.sort
                 @versions = @versions.select {|v| !v.completed? } unless params[:completed]
               end
               def activity
                 if params[:year] and params[:year].to_i > 1900
                   @year = params[:year].to_i
                   if params[:month] and params[:month].to_i > 0 and params[:month].to_i < 13
                     @month = params[:month].to_i
                   end
                 end
                 @year ||= Date.today.year
                 @month ||= Date.today.month
                 case params[:format]
                 when 'atom'
                   # 30 last days
                   @date_from = Date.today - 30
                   @date_to = Date.today + 1
                 else
                   # current month
                   @date_from = Date.civil(@year, @month, 1)
                   @date_to = @date_from >> 1
                 end
                 @event_types = %w(issues news files documents changesets wiki_pages messages)
                 @event_types.delete('wiki_pages') unless @project.wiki
                 @event_types.delete('changesets') unless @project.repository
                 @event_types.delete('messages') unless @project.boards.any?
                 # only show what the user is allowed to view
                 @event_types = @event_types.select {|o| User.current.allowed_to?("view_#{o}".to_sym, @project)}
                 @scope = @event_types.select {|t| params["show_#{t}"]}
                 # default events if none is specified in parameters
                 @scope = (@event_types - %w(wiki_pages messages))if @scope.empty?
                 @events = []
                 if @scope.include?('issues')
                   @events += @project.issues.find(:all, :include => [:author, :tracker], :conditions => ["#{Issue.table_name}.created_on>=? and #{Issue.table_name}.created_on<=?", @date_from, @date_to] )
                   @events += @project.issues_status_changes(@date_from, @date_to)
                 end
                 if @scope.include?('news')
                   @events += @project.news.find(:all, :conditions => ["#{News.table_name}.created_on>=? and #{News.table_name}.created_on<=?", @date_from, @date_to], :include => :author )
                 end
                 if @scope.include?('files')
                   @events += Attachment.find(:all, :select => "#{Attachment.table_name}.*", :joins => "LEFT JOIN #{Version.table_name} ON #{Version.table_name}.id = #{Attachment.table_name}.container_id", :conditions => ["#{Attachment.table_name}.container_type='Version' and #{Version.table_name}.project_id=? and #{Attachment.table_name}.created_on>=? and #{Attachment.table_name}.created_on<=?", @project.id, @date_from, @date_to], :include => :author )
                 end
                 if @scope.include?('documents')
                   @events += @project.documents.find(:all, :conditions => ["#{Document.table_name}.created_on>=? and #{Document.table_name}.created_on<=?", @date_from, @date_to] )
                   @events += Attachment.find(:all, :select => "attachments.*", :joins => "LEFT JOIN #{Document.table_name} ON #{Document.table_name}.id = #{Attachment.table_name}.container_id", :conditions => ["#{Attachment.table_name}.container_type='Document' and #{Document.table_name}.project_id=? and #{Attachment.table_name}.created_on>=? and #{Attachment.table_name}.created_on<=?", @project.id, @date_from, @date_to], :include => :author )
                 end
                 if @scope.include?('wiki_pages')
                   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 "
                   conditions = ["#{Wiki.table_name}.project_id = ? AND #{WikiContent.versioned_table_name}.updated_on BETWEEN ? AND ?",
                                 @project.id, @date_from, @date_to]
                   @events += WikiContent.versioned_class.find(:all, :select => select, :joins => joins, :conditions => conditions)
                 end
                 if @scope.include?('changesets')
                   @events += Changeset.find(:all, :include => :repository, :conditions => ["#{Repository.table_name}.project_id = ? AND #{Changeset.table_name}.committed_on BETWEEN ? AND ?", @project.id, @date_from, @date_to])
                 end
                 if @scope.include?('messages')
                   @events += Message.find(:all,
                                           :include => [:board, :author],
                                           :conditions => ["#{Board.table_name}.project_id=? AND #{Message.table_name}.parent_id IS NULL AND #{Message.table_name}.created_on BETWEEN ? AND ?", @project.id, @date_from, @date_to])
                 end
                 @events_by_day = @events.group_by(&:event_date)
                 respond_to do |format|
                   format.html { render :layout => false if request.xhr? }
                   format.atom { render_feed(@events, :title => "#{@project.name}: #{l(:label_activity)}") }
                 end
               end
               def calendar
                 @trackers = Tracker.find(:all, :order => 'position')
                 retrieve_selected_tracker_ids(@trackers)
                 if params[:year] and params[:year].to_i > 1900
                   @year = params[:year].to_i
                   if params[:month] and params[:month].to_i > 0 and params[:month].to_i < 13
                     @month = params[:month].to_i
                   end
                 end
                 @year ||= Date.today.year
                 @month ||= Date.today.month
                 @calendar = Redmine::Helpers::Calendar.new(Date.civil(@year, @month, 1), current_language, :month)
                 events = []
                 @project.issues_with_subprojects(params[:with_subprojects]) do
                   events += Issue.find(:all,
                                        :include => [:tracker, :status, :assigned_to, :priority, :project],
                                        :conditions => ["((start_date BETWEEN ? AND ?) OR (due_date BETWEEN ? AND ?)) AND #{Issue.table_name}.tracker_id IN (#{@selected_tracker_ids.join(',')})", @calendar.startdt, @calendar.enddt, @calendar.startdt, @calendar.enddt]
                                        ) unless @selected_tracker_ids.empty?
                 end
                 events += @project.versions.find(:all, :conditions => ["effective_date BETWEEN ? AND ?", @calendar.startdt, @calendar.enddt])
                 @calendar.events = events
                 render :layout => false if request.xhr?
               end
               def gantt
                 @trackers = Tracker.find(:all, :order => 'position')
                 retrieve_selected_tracker_ids(@trackers)
                 if params[:year] and params[:year].to_i >0
                   @year_from = params[:year].to_i
                   if params[:month] and params[:month].to_i >=1 and params[:month].to_i <= 12
                     @month_from = params[:month].to_i
                   else
                     @month_from = 1
                   end
                 else
                   @month_from ||= Date.today.month
                   @year_from ||= Date.today.year
                 end
                 zoom = (params[:zoom] || User.current.pref[:gantt_zoom]).to_i
                 @zoom = (zoom > 0 && zoom < 5) ? zoom : 2
                 months = (params[:months] || User.current.pref[:gantt_months]).to_i
                 @months = (months > 0 && months < 25) ? months : 6
                 # Save gantt paramters as user preference (zoom and months count)
                 if (User.current.logged? && (@zoom != User.current.pref[:gantt_zoom] || @months != User.current.pref[:gantt_months]))
                   User.current.pref[:gantt_zoom], User.current.pref[:gantt_months] = @zoom, @months
                   User.current.preference.save
                 end
                 @date_from = Date.civil(@year_from, @month_from, 1)
                 @date_to = (@date_from >> @months) - 1
                 @events = []
                 @project.issues_with_subprojects(params[:with_subprojects]) do
                   @events += Issue.find(:all,
                                        :order => "start_date, due_date",
                                        :include => [:tracker, :status, :assigned_to, :priority, :project],
                                        :conditions => ["(((start_date>=? and start_date<=?) or (due_date>=? and due_date<=?) or (start_date<? and due_date>?)) and start_date is not null and due_date is not null and #{Issue.table_name}.tracker_id in (#{@selected_tracker_ids.join(',')}))", @date_from, @date_to, @date_from, @date_to, @date_from, @date_to]
                                        ) unless @selected_tracker_ids.empty?
                 end
                 @events += @project.versions.find(:all, :conditions => ["effective_date BETWEEN ? AND ?", @date_from, @date_to])
                 @events.sort! {|x,y| x.start_date <=> y.start_date }
                 if params[:format]=='pdf'
                   @options_for_rfpdf ||= {}
                   @options_for_rfpdf[:file_name] = "#{@project.identifier}-gantt.pdf"
                   render :template => "projects/gantt.rfpdf", :layout => false
                 elsif params[:format]=='png' && respond_to?('gantt_image')
                   image = gantt_image(@events, @date_from, @months, @zoom)
                   image.format = 'PNG'
                   send_data(image.to_blob, :disposition => 'inline', :type => 'image/png', :filename => "#{@project.identifier}-gantt.png")
                 else
                   render :template => "projects/gantt.rhtml"
                 end
               end
             private
               # Find project of id params[:id]
               # if not found, redirect to project list
               # Used as a before_filter
               def find_project
                 @project = Project.find(params[:id])
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def retrieve_selected_tracker_ids(selectable_trackers)
                 if ids = params[:tracker_ids]
                   @selected_tracker_ids = (ids.is_a? Array) ? ids.collect { |id| id.to_i.to_s } : ids.split('/').collect { |id| id.to_i.to_s }
                 else
                   @selected_tracker_ids = selectable_trackers.collect {|t| t.id.to_s }
                 end
               end
             end

app/controllers/wiki_controller.rb +1 -5

             # 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
               layout 'base'
               before_filter :find_wiki, :authorize
               verify :method => :post, :only => [:destroy, :destroy_attachment], :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
                 @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
                 render :action => 'show'
               end
               # edit an existing page or a new one
               def edit
                 @page = @wiki.find_or_new_page(params[:page])
                 @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])
                 @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
               # show page history
               def history
                 @page = @wiki.find_page(params[:page])
                 @version_count = @page.content.versions.count
                 @version_pages = Paginator.new self, @version_count, 25, 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
               # remove a wiki page and its history
               def destroy
                 @page = @wiki.find_page(params[:page])
                 @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}
                 # 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])
                 @attachements = page.attachments if page
                 @text = params[:content][:text]
                 render :partial => 'common/preview'
               end
               def add_attachment
                 @page = @wiki.find_page(params[:page])
-                # Save the attachments
+                attach_files(@page, params[:attachments])
-                params[:attachments].each { |file|
-                  next unless file.size > 0
-                  a = Attachment.create(:container => @page, :file => file, :author => User.current)
-                } if params[:attachments] and params[:attachments].is_a? Array
                 redirect_to :action => 'index', :page => @page.title
               end
               def destroy_attachment
                 @page = @wiki.find_page(params[:page])
                 @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
             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