jro_apps/redmine Commit - r11605:2a6dadf78799

Merged r11762 and r11763 from trunk (#13783)....

Jean-Philippe Lang -

r11605:2a6dadf78799

parent child

Context file:

r11605:2a6dadf78799

Collapse all files

app/controllers/enumerations_controller.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 EnumerationsController < ApplicationController
               layout 'admin'
               before_filter :require_admin, :except => :index
               before_filter :require_admin_or_api_request, :only => :index
               before_filter :build_new_enumeration, :only => [:new, :create]
               before_filter :find_enumeration, :only => [:edit, :update, :destroy]
               accept_api_auth :index
               helper :custom_fields
               def index
                 respond_to do |format|
                   format.html
                   format.api {
                     @klass = Enumeration.get_subclass(params[:type])
                     if @klass
                       @enumerations = @klass.shared.sorted.all
                     else
                       render_404
                     end
                   }
                 end
               end
               def new
               end
               def create
                 if request.post? && @enumeration.save
                   flash[:notice] = l(:notice_successful_create)
                   redirect_to enumerations_path
                 else
                   render :action => 'new'
                 end
               end
               def edit
               end
               def update
                 if request.put? && @enumeration.update_attributes(params[:enumeration])
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to enumerations_path
                 else
                   render :action => 'edit'
                 end
               end
               def destroy
                 if !@enumeration.in_use?
                   # No associated objects
                   @enumeration.destroy
                   redirect_to enumerations_path
                   return
                 elsif params[:reassign_to_id]
                   if reassign_to = @enumeration.class.find_by_id(params[:reassign_to_id])
                     @enumeration.destroy(reassign_to)
                     redirect_to enumerations_path
                     return
                   end
                 end
-                @enumerations = @enumeration.class.all - [@enumeration]
+                @enumerations = @enumeration.class.system.all - [@enumeration]
               end
               private
               def build_new_enumeration
                 class_name = params[:enumeration] && params[:enumeration][:type] || params[:type]
                 @enumeration = Enumeration.new_subclass_instance(class_name, params[:enumeration])
                 if @enumeration.nil?
                   render_404
                 end
               end
               def find_enumeration
                 @enumeration = Enumeration.find(params[:id])
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/models/enumeration.rb +1 0

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 Enumeration < ActiveRecord::Base
               include Redmine::SubclassFactory
               default_scope :order => "#{Enumeration.table_name}.position ASC"
               belongs_to :project
               acts_as_list :scope => 'type = \'#{type}\''
               acts_as_customizable
               acts_as_tree :order => "#{Enumeration.table_name}.position ASC"
               before_destroy :check_integrity
               before_save    :check_default
               attr_protected :type
               validates_presence_of :name
               validates_uniqueness_of :name, :scope => [:type, :project_id]
               validates_length_of :name, :maximum => 30
               scope :shared, lambda { where(:project_id => nil) }
               scope :sorted, lambda { order("#{table_name}.position ASC") }
               scope :active, lambda { where(:active => true) }
+              scope :system, lambda { where(:project_id => nil) }
               scope :named, lambda {|arg| where("LOWER(#{table_name}.name) = LOWER(?)", arg.to_s.strip)}
               def self.default
                 # Creates a fake default scope so Enumeration.default will check
                 # it's type.  STI subclasses will automatically add their own
                 # types to the finder.
                 if self.descends_from_active_record?
                   where(:is_default => true, :type => 'Enumeration').first
                 else
                   # STI classes are
                   where(:is_default => true).first
                 end
               end
               # Overloaded on concrete classes
               def option_name
                 nil
               end
               def check_default
                 if is_default? && is_default_changed?
                   Enumeration.update_all({:is_default => false}, {:type => type})
                 end
               end
               # Overloaded on concrete classes
               def objects_count
               end
               def in_use?
                 self.objects_count != 0
               end
               # Is this enumeration overiding a system level enumeration?
               def is_override?
                 !self.parent.nil?
               end
               alias :destroy_without_reassign :destroy
               # Destroy the enumeration
               # If a enumeration is specified, objects are reassigned
               def destroy(reassign_to = nil)
                 if reassign_to && reassign_to.is_a?(Enumeration)
                   self.transfer_relations(reassign_to)
                 end
                 destroy_without_reassign
               end
               def <=>(enumeration)
                 position <=> enumeration.position
               end
               def to_s; name end
               # Returns the Subclasses of Enumeration.  Each Subclass needs to be
               # required in development mode.
               #
               # Note: subclasses is protected in ActiveRecord
               def self.get_subclasses
                 subclasses
               end
               # Does the +new+ Hash override the previous Enumeration?
               def self.overridding_change?(new, previous)
                 if (same_active_state?(new['active'], previous.active)) && same_custom_values?(new,previous)
                   return false
                 else
                   return true
                 end
               end
               # Does the +new+ Hash have the same custom values as the previous Enumeration?
               def self.same_custom_values?(new, previous)
                 previous.custom_field_values.each do |custom_value|
                   if custom_value.value != new["custom_field_values"][custom_value.custom_field_id.to_s]
                     return false
                   end
                 end
                 return true
               end
               # Are the new and previous fields equal?
               def self.same_active_state?(new, previous)
                 new = (new == "1" ? true : false)
                 return new == previous
               end
             private
               def check_integrity
                 raise "Can't delete enumeration" if self.in_use?
               end
             end
             # Force load the subclasses in development mode
             require_dependency 'time_entry_activity'
             require_dependency 'document_category'
             require_dependency 'issue_priority'

app/models/time_entry_activity.rb +6 -2

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 TimeEntryActivity < Enumeration
               has_many :time_entries, :foreign_key => 'activity_id'
               OptionName = :enumeration_activities
               def option_name
                 OptionName
               end
+              def objects
+                TimeEntry.where(:activity_id => self_and_descendants(1).map(&:id))
+              end
               def objects_count
-                time_entries.count
+                objects.count
               end
               def transfer_relations(to)
-                time_entries.update_all("activity_id = #{to.id}")
+                objects.update_all(:activity_id => to.id)
               end
             end

test/object_helpers.rb +2 -1

             module ObjectHelpers
               def User.generate!(attributes={})
                 @generated_user_login ||= 'user0'
                 @generated_user_login.succ!
                 user = User.new(attributes)
                 user.login = @generated_user_login.dup if user.login.blank?
                 user.mail = "#{@generated_user_login}@example.com" if user.mail.blank?
                 user.firstname = "Bob" if user.firstname.blank?
                 user.lastname = "Doe" if user.lastname.blank?
                 yield user if block_given?
                 user.save!
                 user
               end
               def User.add_to_project(user, project, roles=nil)
                 roles = Role.find(1) if roles.nil?
                 roles = [roles] unless roles.is_a?(Array)
                 Member.create!(:principal => user, :project => project, :roles => roles)
               end
               def Group.generate!(attributes={})
                 @generated_group_name ||= 'Group 0'
                 @generated_group_name.succ!
                 group = Group.new(attributes)
                 group.name = @generated_group_name.dup if group.name.blank?
                 yield group if block_given?
                 group.save!
                 group
               end
               def Project.generate!(attributes={})
                 @generated_project_identifier ||= 'project-0000'
                 @generated_project_identifier.succ!
                 project = Project.new(attributes)
                 project.name = @generated_project_identifier.dup if project.name.blank?
                 project.identifier = @generated_project_identifier.dup if project.identifier.blank?
                 yield project if block_given?
                 project.save!
                 project
               end
               def Project.generate_with_parent!(parent, attributes={})
                 project = Project.generate!(attributes)
                 project.set_parent!(parent)
                 project
               end
               def Tracker.generate!(attributes={})
                 @generated_tracker_name ||= 'Tracker 0'
                 @generated_tracker_name.succ!
                 tracker = Tracker.new(attributes)
                 tracker.name = @generated_tracker_name.dup if tracker.name.blank?
                 yield tracker if block_given?
                 tracker.save!
                 tracker
               end
               def Role.generate!(attributes={})
                 @generated_role_name ||= 'Role 0'
                 @generated_role_name.succ!
                 role = Role.new(attributes)
                 role.name = @generated_role_name.dup if role.name.blank?
                 yield role if block_given?
                 role.save!
                 role
               end
               def Issue.generate!(attributes={})
                 issue = Issue.new(attributes)
                 issue.project ||= Project.find(1)
                 issue.tracker ||= issue.project.trackers.first
                 issue.subject = 'Generated' if issue.subject.blank?
                 issue.author ||= User.find(2)
                 yield issue if block_given?
                 issue.save!
                 issue
               end
               # Generates an issue with 2 children and a grandchild
               def Issue.generate_with_descendants!(attributes={})
                 issue = Issue.generate!(attributes)
                 child = Issue.generate!(:project => issue.project, :subject => 'Child1', :parent_issue_id => issue.id)
                 Issue.generate!(:project => issue.project, :subject => 'Child2', :parent_issue_id => issue.id)
                 Issue.generate!(:project => issue.project, :subject => 'Child11', :parent_issue_id => child.id)
                 issue.reload
               end
               def Journal.generate!(attributes={})
                 journal = Journal.new(attributes)
                 journal.user ||= User.first
                 journal.journalized ||= Issue.first
                 yield journal if block_given?
                 journal.save!
                 journal
               end
               def Version.generate!(attributes={})
                 @generated_version_name ||= 'Version 0'
                 @generated_version_name.succ!
                 version = Version.new(attributes)
                 version.name = @generated_version_name.dup if version.name.blank?
                 yield version if block_given?
                 version.save!
                 version
               end
               def TimeEntry.generate!(attributes={})
                 entry = TimeEntry.new(attributes)
                 entry.user ||= User.find(2)
-                entry.issue ||= Issue.find(1)
+                entry.issue ||= Issue.find(1) unless entry.project
                 entry.project ||= entry.issue.project
                 entry.activity ||= TimeEntryActivity.first
                 entry.spent_on ||= Date.today
+                entry.hours ||= 1.0
                 entry.save!
                 entry
               end
               def AuthSource.generate!(attributes={})
                 @generated_auth_source_name ||= 'Auth 0'
                 @generated_auth_source_name.succ!
                 source = AuthSource.new(attributes)
                 source.name = @generated_auth_source_name.dup if source.name.blank?
                 yield source if block_given?
                 source.save!
                 source
               end
               def Board.generate!(attributes={})
                 @generated_board_name ||= 'Forum 0'
                 @generated_board_name.succ!
                 board = Board.new(attributes)
                 board.name = @generated_board_name.dup if board.name.blank?
                 board.description = @generated_board_name.dup if board.description.blank?
                 yield board if block_given?
                 board.save!
                 board
               end
               def Attachment.generate!(attributes={})
                 @generated_filename ||= 'testfile0'
                 @generated_filename.succ!
                 attributes = attributes.dup
                 attachment = Attachment.new(attributes)
                 attachment.container ||= Issue.find(1)
                 attachment.author ||= User.find(2)
                 attachment.filename = @generated_filename.dup if attachment.filename.blank?
                 attachment.save!
                 attachment
               end
             end

test/unit/time_entry_activity_test.rb +29 -1

             # Redmine - project management software
             # Copyright (C) 2006-2013  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class TimeEntryActivityTest < ActiveSupport::TestCase
               fixtures :enumerations, :time_entries, :custom_fields
               include Redmine::I18n
               def test_should_be_an_enumeration
                 assert TimeEntryActivity.ancestors.include?(Enumeration)
               end
               def test_objects_count
                 assert_equal 3, TimeEntryActivity.find_by_name("Design").objects_count
                 assert_equal 2, TimeEntryActivity.find_by_name("Development").objects_count
               end
               def test_option_name
                 assert_equal :enumeration_activities, TimeEntryActivity.new.option_name
               end
               def test_create_with_custom_field
                 field = TimeEntryActivityCustomField.find_by_name('Billable')
                 e = TimeEntryActivity.new(:name => 'Custom Data')
                 e.custom_field_values = {field.id => "1"}
                 assert e.save
                 e.reload
                 assert_equal "1", e.custom_value_for(field).value
               end
               def test_create_without_required_custom_field_should_fail
                 set_language_if_valid 'en'
                 field = TimeEntryActivityCustomField.find_by_name('Billable')
                 field.update_attribute(:is_required, true)
                 e = TimeEntryActivity.new(:name => 'Custom Data')
                 assert !e.save
                 assert_equal ["Billable can't be blank"], e.errors.full_messages
               end
               def test_create_with_required_custom_field_should_succeed
                 field = TimeEntryActivityCustomField.find_by_name('Billable')
                 field.update_attribute(:is_required, true)
                 e = TimeEntryActivity.new(:name => 'Custom Data')
                 e.custom_field_values = {field.id => "1"}
                 assert e.save
               end
               def test_update_with_required_custom_field_change
                 set_language_if_valid 'en'
                 field = TimeEntryActivityCustomField.find_by_name('Billable')
                 field.update_attribute(:is_required, true)
                 e = TimeEntryActivity.find(10)
                 assert e.available_custom_fields.include?(field)
                 # No change to custom field, record can be saved
                 assert e.save
                 # Blanking custom field, save should fail
                 e.custom_field_values = {field.id => ""}
                 assert !e.save
                 assert_equal ["Billable can't be blank"], e.errors.full_messages
                 # Update custom field to valid value, save should succeed
                 e.custom_field_values = {field.id => "0"}
                 assert e.save
                 e.reload
                 assert_equal "0", e.custom_value_for(field).value
               end
-            end
+              def test_system_activity_with_child_in_use_should_be_in_use
+                project = Project.generate!
+                system_activity = TimeEntryActivity.create!(:name => 'Activity')
+                project_activity = TimeEntryActivity.create!(:name => 'Activity', :project => project, :parent_id => system_activity.id)
+                TimeEntry.generate!(:project => project, :activity => project_activity)
+                assert project_activity.in_use?
+                assert system_activity.in_use?
+              end
+              def test_destroying_a_system_activity_should_reassign_children_activities
+                project = Project.generate!
+                system_activity = TimeEntryActivity.create!(:name => 'Activity')
+                project_activity = TimeEntryActivity.create!(:name => 'Activity', :project => project, :parent_id => system_activity.id)
+                entries = [
+                  TimeEntry.generate!(:project => project, :activity => system_activity),
+                  TimeEntry.generate!(:project => project, :activity => project_activity)
+                ]
+                assert_difference 'TimeEntryActivity.count', -2 do
+                  assert_nothing_raised do
+                    assert system_activity.destroy(TimeEntryActivity.find_by_name('Development'))
+                  end
+                end
+                assert entries.all? {|entry| entry.reload.activity.name == 'Development'}
+              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