jro_apps/redmine Commit - r2560:ca166b30e1b2

Adds the ability to move threads between project forums (#2452). 'Edit message' permission is required....

Jean-Philippe Lang -

r2560:ca166b30e1b2

parent child

Context file:

r2560:ca166b30e1b2

Collapse all files

app/controllers/boards_controller.rb +1 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 BoardsController < ApplicationController
               before_filter :find_project, :authorize
               helper :messages
               include MessagesHelper
               helper :sort
               include SortHelper
               helper :watchers
               include WatchersHelper
               def index
                 @boards = @project.boards
                 # show the board if there is only one
                 if @boards.size == 1
                   @board = @boards.first
                   show
                 end
               end
               def show
                 sort_init 'updated_on', 'desc'
                 sort_update	'created_on' => "#{Message.table_name}.created_on",
                             'replies' => "#{Message.table_name}.replies_count",
                             'updated_on' => "#{Message.table_name}.updated_on"
                 @topic_count = @board.topics.count
                 @topic_pages = Paginator.new self, @topic_count, per_page_option, params['page']
                 @topics =  @board.topics.find :all, :order => ["#{Message.table_name}.sticky DESC", sort_clause].compact.join(', '),
                                               :include => [:author, {:last_reply => :author}],
                                               :limit  =>  @topic_pages.items_per_page,
                                               :offset =>  @topic_pages.current.offset
+                @message = Message.new
                 render :action => 'show', :layout => !request.xhr?
               end
               verify :method => :post, :only => [ :destroy ], :redirect_to => { :action => :index }
               def new
                 @board = Board.new(params[:board])
                 @board.project = @project
                 if request.post? && @board.save
                   flash[:notice] = l(:notice_successful_create)
                   redirect_to :controller => 'projects', :action => 'settings', :id => @project, :tab => 'boards'
                 end
               end
               def edit
                 if request.post? && @board.update_attributes(params[:board])
                   redirect_to :controller => 'projects', :action => 'settings', :id => @project, :tab => 'boards'
                 end
               end
               def destroy
                 @board.destroy
                 redirect_to :controller => 'projects', :action => 'settings', :id => @project, :tab => 'boards'
               end
             private
               def find_project
                 @project = Project.find(params[:project_id])
                 @board = @project.boards.find(params[:id]) if params[:id]
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/controllers/messages_controller.rb +2 -1

             # 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
               menu_item :boards
               before_filter :find_board, :only => [:new, :preview]
               before_filter :find_message, :except => [:new, :preview]
               before_filter :authorize, :except => [:preview, :edit, :destroy]
               verify :method => :post, :only => [ :reply, :destroy ], :redirect_to => { :action => :show }
               verify :xhr => true, :only => :quote
               helper :watchers
               helper :attachments
               include AttachmentsHelper
               # Show a topic and its replies
               def show
                 @replies = @topic.children.find(:all, :include => [:author, :attachments, {:board => :project}])
                 @replies.reverse! if User.current.wants_comments_in_reverse_order?
                 @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
                   attach_files(@message, params[:attachments])
                   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?
                   attach_files(@reply, params[:attachments])
                 end
                 redirect_to :action => 'show', :id => @topic
               end
               # Edit a message
               def edit
                 render_403 and return false unless @message.editable_by?(User.current)
                 if params[:message]
                   @message.locked = params[:message]['locked']
                   @message.sticky = params[:message]['sticky']
                 end
                 if request.post? && @message.update_attributes(params[:message])
                   attach_files(@message, params[:attachments])
                   flash[:notice] = l(:notice_successful_update)
-                  redirect_to :action => 'show', :id => @topic
+                  @message.reload
+                  redirect_to :action => 'show', :board_id => @message.board, :id => @message.root
                 end
               end
               # Delete a messages
               def destroy
                 render_403 and return false unless @message.destroyable_by?(User.current)
                 @message.destroy
                 redirect_to @message.parent.nil? ?
                   { :controller => 'boards', :action => 'show', :project_id => @project, :id => @board } :
                   { :action => 'show', :id => @message.parent }
               end
               def quote
                 user = @message.author
                 text = @message.content
                 content = "#{ll(Setting.default_language, :text_user_wrote, user)}\\n> "
                 content << text.to_s.strip.gsub(%r{<pre>((.|\s)*?)</pre>}m, '[...]').gsub('"', '\"').gsub(/(\r?\n|\r\n?)/, "\\n> ") + "\\n\\n"
                 render(:update) { |page|
                   page.<< "$('message_content').value = \"#{content}\";"
                   page.show 'reply'
                   page << "Form.Element.focus('message_content');"
                   page << "Element.scrollTo('reply');"
                   page << "$('message_content').scrollTop = $('message_content').scrollHeight - $('message_content').clientHeight;"
                 }
               end
               def preview
                 message = @board.messages.find_by_id(params[:id])
                 @attachements = message.attachments if message
                 @text = (params[:message] || params[:reply])[:content]
                 render :partial => 'common/preview'
               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/models/board.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 Board < ActiveRecord::Base
               belongs_to :project
               has_many :topics, :class_name => 'Message', :conditions => "#{Message.table_name}.parent_id IS NULL", :order => "#{Message.table_name}.created_on DESC"
               has_many :messages, :dependent => :delete_all, :order => "#{Message.table_name}.created_on DESC"
               belongs_to :last_message, :class_name => 'Message', :foreign_key => :last_message_id
               acts_as_list :scope => :project_id
               acts_as_watchable
               validates_presence_of :name, :description
               validates_length_of :name, :maximum => 30
               validates_length_of :description, :maximum => 255
+              def reset_counters!
+                self.class.reset_counters!(id)
+              end
+              # Updates topics_count, messages_count and last_message_id attributes for +board_id+
+              def self.reset_counters!(board_id)
+                board_id = board_id.to_i
+                update_all("topics_count = (SELECT COUNT(*) FROM #{Message.table_name} WHERE board_id=#{board_id} AND parent_id IS NULL)," +
+                           " messages_count = (SELECT COUNT(*) FROM #{Message.table_name} WHERE board_id=#{board_id})," +
+                           " last_message_id = (SELECT MAX(id) FROM #{Message.table_name} WHERE board_id=#{board_id})",
+                           ["id = ?", board_id])
+              end
             end

app/models/message.rb +11 -10

             # 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 Message < ActiveRecord::Base
               belongs_to :board
               belongs_to :author, :class_name => 'User', :foreign_key => 'author_id'
               acts_as_tree :counter_cache => :replies_count, :order => "#{Message.table_name}.created_on ASC"
               acts_as_attachable
               belongs_to :last_reply, :class_name => 'Message', :foreign_key => 'last_reply_id'
               acts_as_searchable :columns => ['subject', 'content'],
                                  :include => {:board => :project},
                                  :project_key => 'project_id',
                                  :date_column => "#{table_name}.created_on"
               acts_as_event :title => Proc.new {|o| "#{o.board.name}: #{o.subject}"},
                             :description => :content,
                             :type => Proc.new {|o| o.parent_id.nil? ? 'message' : 'reply'},
                             :url => Proc.new {|o| {:controller => 'messages', :action => 'show', :board_id => o.board_id}.merge(o.parent_id.nil? ? {:id => o.id} :
                                                                                                                                                    {:id => o.parent_id, :anchor => "message-#{o.id}"})}
               acts_as_activity_provider :find_options => {:include => [{:board => :project}, :author]},
                                         :author_key => :author_id
               acts_as_watchable
               attr_protected :locked, :sticky
-              validates_presence_of :subject, :content
+              validates_presence_of :board, :subject, :content
               validates_length_of :subject, :maximum => 255
               after_create :add_author_as_watcher
               def validate_on_create
                 # Can not reply to a locked topic
                 errors.add_to_base 'Topic is locked' if root.locked? && self != root
               end
               def after_create
-                board.update_attribute(:last_message_id, self.id)
-                board.increment! :messages_count
                 if parent
                   parent.reload.update_attribute(:last_reply_id, self.id)
-                else
+                end
-                  board.increment! :topics_count
+                board.reset_counters!
+              end
+              def after_update
+                if board_id_changed?
+                  Message.update_all("board_id = #{board_id}", ["id = ? OR parent_id = ?", root.id, root.id])
+                  Board.reset_counters!(board_id_was)
+                  Board.reset_counters!(board_id)
                 end
               end
               def after_destroy
-                # The following line is required so that the previous counter
+                board.reset_counters!
-                # updates (due to children removal) are not overwritten
-                board.reload
-                board.decrement! :messages_count
-                board.decrement! :topics_count unless parent
               end
               def sticky?
                 sticky == 1
               end
               def project
                 board.project
               end
               def editable_by?(usr)
                 usr && usr.logged? && (usr.allowed_to?(:edit_messages, project) || (self.author == usr && usr.allowed_to?(:edit_own_messages, project)))
               end
               def destroyable_by?(usr)
                 usr && usr.logged? && (usr.allowed_to?(:delete_messages, project) || (self.author == usr && usr.allowed_to?(:delete_own_messages, project)))
               end
               private
               def add_author_as_watcher
                 Watcher.create(:watchable => self.root, :user => author)
               end
             end

app/views/messages/_form.rhtml +5 0

             <%= error_messages_for 'message' %>
             <% replying ||= false %>
             <div class="box">
             <!--[form:message]-->
             <p><label><%= l(:field_subject) %></label><br />
             <%= f.text_field :subject, :size => 120 %>
             <% if !replying && User.current.allowed_to?(:edit_messages, @project) %>
                 <label><%= f.check_box :sticky %> Sticky</label>
                 <label><%= f.check_box :locked %> Locked</label>
             <% end %>
             </p>
+            <% if !replying && !@message.new_record? && User.current.allowed_to?(:edit_messages, @project) %>
+            	<p><label><%= l(:label_board) %></label><br />
+              <%= f.select :board_id, @project.boards.collect {|b| [b.name, b.id]} %></p>
+            <% end %>
             <p><%= f.text_area :content, :cols => 80, :rows => 15, :class => 'wiki-edit', :id => 'message_content' %></p>
             <%= wikitoolbar_for 'message_content' %>
             <!--[eoform:message]-->
             <p><%= l(:label_attachment_plural) %><br />
             <%= render :partial => 'attachments/form' %></p>
             </div>

test/fixtures/boards.yml +2 -2

             ---
             boards_001:
               name: Help
               project_id: 1
               topics_count: 2
               id: 1
               description: Help board
               position: 1
-              last_message_id: 5
+              last_message_id: 6
-              messages_count: 5
+              messages_count: 6
             boards_002:
               name: Discussion
               project_id: 1
               topics_count: 0
               id: 2
               description: Discussion board
               position: 2
               last_message_id:
               messages_count: 0

test/unit/message_test.rb +34 0

+            # Redmine - project management software
+            # Copyright (C) 2006-2009  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.dirname(__FILE__) + '/../test_helper'
             class MessageTest < Test::Unit::TestCase
               fixtures :projects, :roles, :members, :boards, :messages, :users, :watchers
               def setup
                 @board = Board.find(1)
                 @user = User.find(1)
               end
               def test_create
                 topics_count = @board.topics_count
                 messages_count = @board.messages_count
                 message = Message.new(:board => @board, :subject => 'Test message', :content => 'Test message content', :author => @user)
                 assert message.save
                 @board.reload
                 # topics count incremented
                 assert_equal topics_count+1, @board[:topics_count]
                 # messages count incremented
                 assert_equal messages_count+1, @board[:messages_count]
                 assert_equal message, @board.last_message
                 # author should be watching the message
                 assert message.watched_by?(@user)
               end
               def test_reply
                 topics_count = @board.topics_count
                 messages_count = @board.messages_count
                 @message = Message.find(1)
                 replies_count = @message.replies_count
                 reply_author = User.find(2)
                 reply = Message.new(:board => @board, :subject => 'Test reply', :content => 'Test reply content', :parent => @message, :author => reply_author)
                 assert reply.save
                 @board.reload
                 # same topics count
                 assert_equal topics_count, @board[:topics_count]
                 # messages count incremented
                 assert_equal messages_count+1, @board[:messages_count]
                 assert_equal reply, @board.last_message
                 @message.reload
                 # replies count incremented
                 assert_equal replies_count+1, @message[:replies_count]
                 assert_equal reply, @message.last_reply
                 # author should be watching the message
                 assert @message.watched_by?(reply_author)
               end
+              def test_moving_message_should_update_counters
+                @message = Message.find(1)
+                assert_no_difference 'Message.count' do
+                  # Previous board
+                  assert_difference 'Board.find(1).topics_count', -1 do
+                    assert_difference 'Board.find(1).messages_count', -(1 + @message.replies_count) do
+                      # New board
+                      assert_difference 'Board.find(2).topics_count' do
+                        assert_difference 'Board.find(2).messages_count', (1 + @message.replies_count) do
+                          @message.update_attributes(:board_id => 2)
+                        end
+                      end
+                    end
+                  end
+                end
+              end
               def test_destroy_topic
                 message = Message.find(1)
                 board = message.board
                 topics_count, messages_count = board.topics_count, board.messages_count
                 assert_difference('Watcher.count', -1) do
                   assert message.destroy
                 end
                 board.reload
                 # Replies deleted
                 assert Message.find_all_by_parent_id(1).empty?
                 # Checks counters
                 assert_equal topics_count - 1, board.topics_count
                 assert_equal messages_count - 3, board.messages_count
                 # Watchers removed
               end
               def test_destroy_reply
                 message = Message.find(5)
                 board = message.board
                 topics_count, messages_count = board.topics_count, board.messages_count
                 assert message.destroy
                 board.reload
                 # Checks counters
                 assert_equal topics_count, board.topics_count
                 assert_equal messages_count - 1, board.messages_count
               end
               def test_editable_by
                 message = Message.find(6)
                 author = message.author
                 assert message.editable_by?(author)
                 author.role_for_project(message.project).remove_permission!(:edit_own_messages)
                 assert !message.reload.editable_by?(author.reload)
               end
               def test_destroyable_by
                 message = Message.find(6)
                 author = message.author
                 assert message.destroyable_by?(author)
                 author.role_for_project(message.project).remove_permission!(:delete_own_messages)
                 assert !message.reload.destroyable_by?(author.reload)
               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