jro_apps/redmine Commit - r8725:60b9e59d1580

Displays the full form when creating a version from the issue form so that required custom fields can be filled (#7398)....

Jean-Philippe Lang -

r8725:60b9e59d1580

parent child

Context file:

r8725:60b9e59d1580

Collapse all files

app/views/versions/_new_modal.html.erb created 644 +9 0

@@ -0,0 +1,9
	1	<h3 class="title"><%=l(:label_version_new)%></h3>
	2
	3	<% labelled_remote_form_for @version, :url => project_versions_path(@project) do \|f\| %>
	4	<%= render :partial => 'versions/form', :locals => { :f => f } %>
	5	<p class="buttons">
	6	<%= submit_tag l(:button_create), :name => nil %>
	7	<%= submit_tag l(:button_cancel), :name => nil, :onclick => "hideModal(this);", :type => 'button' %>
	8	</p>
	9	<% end %>

app/controllers/versions_controller.rb +20 -4

             # Redmine - project management software
             # Copyright (C) 2006-2011  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class VersionsController < ApplicationController
               menu_item :roadmap
               model_object Version
               before_filter :find_model_object, :except => [:index, :new, :create, :close_completed]
               before_filter :find_project_from_association, :except => [:index, :new, :create, :close_completed]
               before_filter :find_project, :only => [:index, :new, :create, :close_completed]
               before_filter :authorize
               accept_api_auth :index, :create, :update, :destroy
               helper :custom_fields
               helper :projects
               def index
                 respond_to do |format|
                   format.html {
                     @trackers = @project.trackers.find(:all, :order => 'position')
                     retrieve_selected_tracker_ids(@trackers, @trackers.select {|t| t.is_in_roadmap?})
                     @with_subprojects = params[:with_subprojects].nil? ? Setting.display_subprojects_issues? : (params[:with_subprojects] == '1')
                     project_ids = @with_subprojects ? @project.self_and_descendants.collect(&:id) : [@project.id]
                     @versions = @project.shared_versions || []
                     @versions += @project.rolled_up_versions.visible if @with_subprojects
                     @versions = @versions.uniq.sort
                     unless params[:completed]
                       @completed_versions = @versions.select {|version| version.closed? || version.completed? }
                       @versions -= @completed_versions
                     end
                     @issues_by_version = {}
                     unless @selected_tracker_ids.empty?
                       @versions.each do |version|
                         issues = version.fixed_issues.visible.find(:all,
                                                                    :include => [:project, :status, :tracker, :priority],
                                                                    :conditions => {:tracker_id => @selected_tracker_ids, :project_id => project_ids},
                                                                    :order => "#{Project.table_name}.lft, #{Tracker.table_name}.position, #{Issue.table_name}.id")
                         @issues_by_version[version] = issues
                       end
                     end
                     @versions.reject! {|version| !project_ids.include?(version.project_id) && @issues_by_version[version].blank?}
                   }
                   format.api {
                     @versions = @project.shared_versions.all
                   }
                 end
               end
               def show
                 respond_to do |format|
                   format.html {
                     @issues = @version.fixed_issues.visible.find(:all,
                       :include => [:status, :tracker, :priority],
                       :order => "#{Tracker.table_name}.position, #{Issue.table_name}.id")
                   }
                   format.api
                 end
               end
               def new
                 @version = @project.versions.build(params[:version])
+                respond_to do |format|
+                  format.html
+                  format.js do
+                    render :update do |page|
+                      page.replace_html 'ajax-modal', :partial => 'versions/new_modal'
+                      page << "showModal('ajax-modal', '600px');"
+                      page << "Form.Element.focus('version_name');"
+                    end
+                  end
+                end
               end
               def create
                 @version = @project.versions.build
                 if params[:version]
                   attributes = params[:version].dup
                   attributes.delete('sharing') unless attributes.nil? || @version.allowed_sharings.include?(attributes['sharing'])
                   @version.attributes = attributes
                 end
                 if request.post?
                   if @version.save
                     respond_to do |format|
                       format.html do
                         flash[:notice] = l(:notice_successful_create)
                         redirect_back_or_default :controller => 'projects', :action => 'settings', :tab => 'versions', :id => @project
                       end
                       format.js do
-                        # IE doesn't support the replace_html rjs method for select box options
+                        render(:update) {|page|
-                        render(:update) {|page| page.replace "issue_fixed_version_id",
+                          page << 'hideModal();'
-                          content_tag('select', '<option></option>' + version_options_for_select(@project.shared_versions.open, @version), :id => 'issue_fixed_version_id', :name => 'issue[fixed_version_id]')
+                          # IE doesn't support the replace_html rjs method for select box options
+                          page.replace "issue_fixed_version_id",
+                            content_tag('select', '<option></option>' + version_options_for_select(@project.shared_versions.open, @version), :id => 'issue_fixed_version_id', :name => 'issue[fixed_version_id]')
                         }
                       end
                       format.api do
                         render :action => 'show', :status => :created, :location => version_url(@version)
                       end
                     end
                   else
                     respond_to do |format|
                       format.html { render :action => 'new' }
                       format.js do
-                        render(:update) {|page| page.alert(@version.errors.full_messages.join('\n')) }
+                        render :update do |page|
+                          page.replace_html 'ajax-modal', :partial => 'versions/new_modal'
+                          page << "Form.Element.focus('version_name');"
+                        end
                       end
                       format.api  { render_validation_errors(@version) }
                     end
                   end
                 end
               end
               def edit
               end
               def update
                 if request.put? && params[:version]
                   attributes = params[:version].dup
                   attributes.delete('sharing') unless @version.allowed_sharings.include?(attributes['sharing'])
                   if @version.update_attributes(attributes)
                     respond_to do |format|
                       format.html {
                         flash[:notice] = l(:notice_successful_update)
                         redirect_back_or_default :controller => 'projects', :action => 'settings', :tab => 'versions', :id => @project
                       }
                       format.api  { head :ok }
                     end
                   else
                     respond_to do |format|
                       format.html { render :action => 'edit' }
                       format.api  { render_validation_errors(@version) }
                     end
                   end
                 end
               end
               def close_completed
                 if request.put?
                   @project.close_completed_versions
                 end
                 redirect_to :controller => 'projects', :action => 'settings', :tab => 'versions', :id => @project
               end
               verify :method => :delete, :only => :destroy, :render => {:nothing => true, :status => :method_not_allowed }
               def destroy
                 if @version.fixed_issues.empty?
                   @version.destroy
                   respond_to do |format|
                     format.html { redirect_back_or_default :controller => 'projects', :action => 'settings', :tab => 'versions', :id => @project }
                     format.api  { head :ok }
                   end
                 else
                   respond_to do |format|
                     format.html {
                       flash[:error] = l(:notice_unable_delete_version)
                       redirect_to :controller => 'projects', :action => 'settings', :tab => 'versions', :id => @project
                     }
                     format.api  { head :unprocessable_entity }
                   end
                 end
               end
               def status_by
                 respond_to do |format|
                   format.html { render :action => 'show' }
                   format.js { render(:update) {|page| page.replace_html 'status_by', render_issue_status_by(@version, params[:status_by])} }
                 end
               end
             private
               def find_project
                 @project = Project.find(params[:project_id])
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def retrieve_selected_tracker_ids(selectable_trackers, default_trackers=nil)
                 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 = (default_trackers || selectable_trackers).collect {|t| t.id.to_s }
                 end
               end
             end

app/views/issues/_attributes.html.erb +4 -6

             <% labelled_fields_for :issue, @issue do |f| %>
             <div class="splitcontentleft">
             <% if @issue.safe_attribute? 'status_id'  %>
             <p><%= f.select :status_id, (@allowed_statuses.collect {|p| [p.name, p.id]}), :required => true %></p>
             <% else %>
             <p><label><%= l(:field_status) %></label> <%= h(@issue.status.name) %></p>
             <% end %>
             <% if @issue.safe_attribute? 'priority_id' %>
             <p><%= f.select :priority_id, (@priorities.collect {|p| [p.name, p.id]}), {:required => true}, :disabled => !@issue.leaf? %></p>
             <% end %>
             <% if @issue.safe_attribute? 'assigned_to_id' %>
             <p><%= f.select :assigned_to_id, principals_options_for_select(@issue.assignable_users, @issue.assigned_to), :include_blank => true %></p>
             <% end %>
             <% if @issue.safe_attribute?('category_id') && @issue.project.issue_categories.any? %>
             <p><%= f.select :category_id, (@issue.project.issue_categories.collect {|c| [c.name, c.id]}), :include_blank => true %>
             <%= prompt_to_remote(image_tag('add.png', :style => 'vertical-align: middle;'),
                                  l(:label_issue_category_new),
                                  'issue_category[name]',
                                  {:controller => 'issue_categories', :action => 'create', :project_id => @issue.project},
                                  :title => l(:label_issue_category_new),
                                  :tabindex => 199) if User.current.allowed_to?(:manage_categories, @issue.project) %></p>
             <% end %>
             <% if @issue.safe_attribute?('fixed_version_id') && @issue.assignable_versions.any? %>
             <p><%= f.select :fixed_version_id, version_options_for_select(@issue.assignable_versions, @issue.fixed_version), :include_blank => true %>
-            <%= prompt_to_remote(image_tag('add.png', :style => 'vertical-align: middle;'),
+            <%= link_to_remote(image_tag('add.png', :style => 'vertical-align: middle;'),
-                                 l(:label_version_new),
+                               {:url => new_project_version_path(@issue.project), :method => 'get'},
-                                 'version[name]',
+                               :title => l(:label_version_new),
-                                 {:controller => 'versions', :action => 'create', :project_id => @issue.project},
+                               :tabindex => 200) if User.current.allowed_to?(:manage_versions, @issue.project) %>
-                                 :title => l(:label_version_new),
-                                 :tabindex => 200) if User.current.allowed_to?(:manage_versions, @issue.project) %>
             </p>
             <% end %>
             </div>
             <div class="splitcontentright">
             <% if @issue.safe_attribute? 'parent_issue_id' %>
             <p id="parent_issue"><%= f.text_field :parent_issue_id, :size => 10 %></p>
             <div id="parent_issue_candidates" class="autocomplete"></div>
             <%= javascript_tag "observeParentIssueField('#{auto_complete_issues_path(:id => @issue, :project_id => @issue.project) }')" %>
             <% end %>
             <% if @issue.safe_attribute? 'start_date' %>
             <p><%= f.text_field :start_date, :size => 10, :disabled => !@issue.leaf? %><%= calendar_for('issue_start_date') if @issue.leaf? %></p>
             <% end %>
             <% if @issue.safe_attribute? 'due_date' %>
             <p><%= f.text_field :due_date, :size => 10, :disabled => !@issue.leaf? %><%= calendar_for('issue_due_date') if @issue.leaf? %></p>
             <% end %>
             <% if @issue.safe_attribute? 'estimated_hours' %>
             <p><%= f.text_field :estimated_hours, :size => 3, :disabled => !@issue.leaf? %> <%= l(:field_hours) %></p>
             <% end %>
             <% if @issue.safe_attribute?('done_ratio') && @issue.leaf? && Issue.use_field_for_done_ratio? %>
             <p><%= f.select :done_ratio, ((0..10).to_a.collect {|r| ["#{r*10} %", r*10] }) %></p>
             <% end %>
             </div>
             <div style="clear:both;"> </div>
             <% if @issue.safe_attribute? 'custom_field_values' %>
             <%= render :partial => 'issues/form_custom_fields' %>
             <% end %>
             <% end %>

public/javascripts/application.js +6 -1

             /* Redmine - project management software
                Copyright (C) 2006-2012  Jean-Philippe Lang */
             function checkAll (id, checked) {
               var els = Element.descendants(id);
               for (var i = 0; i < els.length; i++) {
                 if (els[i].disabled==false) {
                   els[i].checked = checked;
                 }
               }
             }
             function toggleCheckboxesBySelector(selector) {
               boxes = $$(selector);
               var all_checked = true;
               for (i = 0; i < boxes.length; i++) { if (boxes[i].checked == false) { all_checked = false; } }
               for (i = 0; i < boxes.length; i++) { boxes[i].checked = !all_checked; }
             }
             function setCheckboxesBySelector(checked, selector) {
               var boxes = $$(selector);
               boxes.each(function(ele) {
                 ele.checked = checked;
               });
             }
             function showAndScrollTo(id, focus) {
               Element.show(id);
               if (focus!=null) { Form.Element.focus(focus); }
               Element.scrollTo(id);
             }
             function toggleRowGroup(el) {
               var tr = Element.up(el, 'tr');
               var n = Element.next(tr);
               tr.toggleClassName('open');
               while (n != undefined && !n.hasClassName('group')) {
                 Element.toggle(n);
                 n = Element.next(n);
               }
             }
             function collapseAllRowGroups(el) {
               var tbody = Element.up(el, 'tbody');
               tbody.childElements('tr').each(function(tr) {
                 if (tr.hasClassName('group')) {
                   tr.removeClassName('open');
                 } else {
                   tr.hide();
                 }
               })
             }
             function expandAllRowGroups(el) {
               var tbody = Element.up(el, 'tbody');
               tbody.childElements('tr').each(function(tr) {
                 if (tr.hasClassName('group')) {
                   tr.addClassName('open');
                 } else {
                   tr.show();
                 }
               })
             }
             function toggleAllRowGroups(el) {
               var tr = Element.up(el, 'tr');
               if (tr.hasClassName('open')) {
                 collapseAllRowGroups(el);
               } else {
                 expandAllRowGroups(el);
               }
             }
             function toggleFieldset(el) {
               var fieldset = Element.up(el, 'fieldset');
               fieldset.toggleClassName('collapsed');
               Effect.toggle(fieldset.down('div'), 'slide', {duration:0.2});
             }
             function hideFieldset(el) {
               var fieldset = Element.up(el, 'fieldset');
               fieldset.toggleClassName('collapsed');
               fieldset.down('div').hide();
             }
             function add_filter() {
               select = $('add_filter_select');
               field = select.value
               Element.show('tr_' +  field);
               check_box = $('cb_' + field);
               check_box.checked = true;
               toggle_filter(field);
               select.selectedIndex = 0;
               for (i=0; i<select.options.length; i++) {
                 if (select.options[i].value == field) {
                   select.options[i].disabled = true;
                 }
               }
             }
             function toggle_filter(field) {
               check_box = $('cb_' + field);
               if (check_box.checked) {
                 Element.show("operators_" + field);
                 Form.Element.enable("operators_" + field);
                 toggle_operator(field);
               } else {
                 Element.hide("operators_" + field);
                 Form.Element.disable("operators_" + field);
                 enableValues(field, []);
               }
             }
             function enableValues(field, indexes) {
               var f = $$(".values_" + field);
               for(var i=0;i<f.length;i++) {
                 if (indexes.include(i)) {
                   Form.Element.enable(f[i]);
                   f[i].up('span').show();
                 } else {
                   f[i].value = '';
                   Form.Element.disable(f[i]);
                   f[i].up('span').hide();
                 }
               }
               if (indexes.length > 0) {
                 Element.show("div_values_" + field);
               } else {
                 Element.hide("div_values_" + field);
               }
             }
             function toggle_operator(field) {
               operator = $("operators_" + field);
               switch (operator.value) {
                 case "!*":
                 case "*":
                 case "t":
                 case "w":
                 case "o":
                 case "c":
                   enableValues(field, []);
                   break;
                 case "><":
                   enableValues(field, [0,1]);
                   break;
                 case "<t+":
                 case ">t+":
                 case "t+":
                 case ">t-":
                 case "<t-":
                 case "t-":
                   enableValues(field, [2]);
                   break;
                 default:
                   enableValues(field, [0]);
                   break;
               }
             }
             function toggle_multi_select(el) {
               var select = $(el);
               if (select.multiple == true) {
                 select.multiple = false;
               } else {
                 select.multiple = true;
               }
             }
             function submit_query_form(id) {
               selectAllOptions("selected_columns");
               $(id).submit();
             }
             function apply_filters_observer() {
               $$("#query_form input[type=text]").invoke("observe", "keypress", function(e){
                 if(e.keyCode == Event.KEY_RETURN) {
                   submit_query_form("query_form");
                 }
               });
             }
             var fileFieldCount = 1;
             function addFileField() {
               var fields = $('attachments_fields');
               if (fields.childElements().length >= 10) return false;
               fileFieldCount++;
               var s = new Element('span');
               s.update(fields.down('span').innerHTML);
               s.down('input.file').name = "attachments[" + fileFieldCount + "][file]";
               s.down('input.description').name = "attachments[" + fileFieldCount + "][description]";
               fields.appendChild(s);
             }
             function removeFileField(el) {
               var fields = $('attachments_fields');
               var s = Element.up(el, 'span');
               if (fields.childElements().length > 1) {
                 s.remove();
               } else {
                 s.update(s.innerHTML);
               }
             }
             function checkFileSize(el, maxSize, message) {
               var files = el.files;
               if (files) {
                 for (var i=0; i<files.length; i++) {
                   if (files[i].size > maxSize) {
                     alert(message);
                     el.value = "";
                   }
                 }
               }
             }
             function showTab(name) {
               var f = $$('div#content .tab-content');
               for(var i=0; i<f.length; i++){
                 Element.hide(f[i]);
               }
               var f = $$('div.tabs a');
               for(var i=0; i<f.length; i++){
                 Element.removeClassName(f[i], "selected");
               }
               Element.show('tab-content-' + name);
               Element.addClassName('tab-' + name, "selected");
               return false;
             }
             function moveTabRight(el) {
               var lis = Element.up(el, 'div.tabs').down('ul').childElements();
               var tabsWidth = 0;
               var i;
               for (i=0; i<lis.length; i++) {
                 if (lis[i].visible()) {
                   tabsWidth += lis[i].getWidth() + 6;
                 }
               }
               if (tabsWidth < Element.up(el, 'div.tabs').getWidth() - 60) {
                 return;
               }
               i=0;
               while (i<lis.length && !lis[i].visible()) {
                 i++;
               }
               lis[i].hide();
             }
             function moveTabLeft(el) {
               var lis = Element.up(el, 'div.tabs').down('ul').childElements();
               var i = 0;
               while (i<lis.length && !lis[i].visible()) {
                 i++;
               }
               if (i>0) {
                 lis[i-1].show();
               }
             }
             function displayTabsButtons() {
               var lis;
               var tabsWidth = 0;
               var i;
               $$('div.tabs').each(function(el) {
                 lis = el.down('ul').childElements();
                 for (i=0; i<lis.length; i++) {
                   if (lis[i].visible()) {
                     tabsWidth += lis[i].getWidth() + 6;
                   }
                 }
                 if ((tabsWidth < el.getWidth() - 60) && (lis[0].visible())) {
                   el.down('div.tabs-buttons').hide();
                 } else {
                   el.down('div.tabs-buttons').show();
                 }
               });
             }
             function setPredecessorFieldsVisibility() {
                 relationType = $('relation_relation_type');
                 if (relationType && (relationType.value == "precedes" || relationType.value == "follows")) {
                     Element.show('predecessor_fields');
                 } else {
                     Element.hide('predecessor_fields');
                 }
             }
             function promptToRemote(text, param, url) {
                 value = prompt(text + ':');
                 if (value) {
                     new Ajax.Request(url + '?' + param + '=' + encodeURIComponent(value), {asynchronous:true, evalScripts:true});
                     return false;
                 }
             }
             function showModal(id, width) {
               el = $(id);
               if (el == undefined || el.visible()) {return;}
               var h = $$('body')[0].getHeight();
               var d = document.createElement("div");
               d.id = 'modalbg';
               $('main').appendChild(d);
               $('modalbg').setStyle({ width: '100%', height: h + 'px' });
               $('modalbg').show();
               var pageWidth = document.viewport.getWidth();
               if (width) {
                 el.setStyle({'width': width});
               }
               el.setStyle({'left': (((pageWidth - el.getWidth())/2  *100) / pageWidth) + '%'});
               el.addClassName('modal');
               el.show();
               var submit = el.down("input[type=submit]");
               if (submit) {
                 submit.focus();
               }
             }
             function hideModal(el) {
-              var modal = Element.up(el, 'div.modal');
+              var modal;
+            	if (el) {
+            		modal = Element.up(el, 'div.modal');
+            	} else {
+            		modal = $('ajax-modal');
+            	}
               if (modal) {
                 modal.hide();
               }
               var bg = $('modalbg');
               if (bg) {
                 bg.remove();
               }
             }
             function collapseScmEntry(id) {
               var els = document.getElementsByClassName(id, 'browser');
               for (var i = 0; i < els.length; i++) {
                  if (els[i].hasClassName('open')) {
                      collapseScmEntry(els[i].id);
                  }
                  Element.hide(els[i]);
               }
               $(id).removeClassName('open');
             }
             function expandScmEntry(id) {
                 var els = document.getElementsByClassName(id, 'browser');
                 for (var i = 0; i < els.length; i++) {
                    Element.show(els[i]);
                    if (els[i].hasClassName('loaded') && !els[i].hasClassName('collapsed')) {
                         expandScmEntry(els[i].id);
                    }
                 }
                 $(id).addClassName('open');
             }
             function scmEntryClick(id) {
                 el = $(id);
                 if (el.hasClassName('open')) {
                     collapseScmEntry(id);
                     el.addClassName('collapsed');
                     return false;
                 } else if (el.hasClassName('loaded')) {
                     expandScmEntry(id);
                     el.removeClassName('collapsed');
                     return false;
                 }
                 if (el.hasClassName('loading')) {
                     return false;
                 }
                 el.addClassName('loading');
                 return true;
             }
             function scmEntryLoaded(id) {
                 Element.addClassName(id, 'open');
                 Element.addClassName(id, 'loaded');
                 Element.removeClassName(id, 'loading');
             }
             function randomKey(size) {
               var chars = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z');
               var key = '';
               for (i = 0; i < size; i++) {
                 key += chars[Math.floor(Math.random() * chars.length)];
               }
               return key;
             }
             function observeParentIssueField(url) {
               new Ajax.Autocompleter('issue_parent_issue_id',
                                      'parent_issue_candidates',
                                      url,
                                      { minChars: 3,
                                        frequency: 0.5,
                                        paramName: 'q',
                                        method: 'get',
                                        updateElement: function(value) {
                                          document.getElementById('issue_parent_issue_id').value = value.id;
                                        }});
             }
             function observeRelatedIssueField(url) {
               new Ajax.Autocompleter('relation_issue_to_id',
                                      'related_issue_candidates',
                                      url,
                                      { minChars: 3,
                                        frequency: 0.5,
                                        paramName: 'q',
                                        method: 'get',
                                        updateElement: function(value) {
                                          document.getElementById('relation_issue_to_id').value = value.id;
                                        },
                                        parameters: 'scope=all'
                                        });
             }
             function setVisible(id, visible) {
               var el = $(id);
               if (el) {if (visible) {el.show();} else {el.hide();}}
             }
             function observeProjectModules() {
               var f = function() {
                 /* Hides trackers and issues custom fields on the new project form when issue_tracking module is disabled */
                 var c = ($('project_enabled_module_names_issue_tracking').checked == true);
                 setVisible('project_trackers', c);
                 setVisible('project_issue_custom_fields', c);
               };
               Event.observe(window, 'load', f);
               Event.observe('project_enabled_module_names_issue_tracking', 'change', f);
             }
             /*
              * Class used to warn user when leaving a page with unsaved textarea
              * Author: mathias.fischer@berlinonline.de
             */
             var WarnLeavingUnsaved = Class.create({
               observedForms: false,
               observedElements: false,
               changedForms: false,
               message: null,
               initialize: function(message){
                 this.observedForms = $$('form');
                 this.observedElements =  $$('textarea');
                 this.message = message;
                 this.observedElements.each(this.observeChange.bind(this));
                 this.observedForms.each(this.submitAction.bind(this));
                 window.onbeforeunload = this.unload.bind(this);
               },
               unload: function(){
                 this.observedElements.each(function(el) {el.blur();})
                 if(this.changedForms)
                   return this.message;
               },
               setChanged: function(){
                 this.changedForms = true;
               },
               setUnchanged: function(){
                 this.changedForms = false;
               },
               observeChange: function(element){
                 element.observe('change',this.setChanged.bindAsEventListener(this));
               },
               submitAction: function(element){
                 element.observe('submit',this.setUnchanged.bindAsEventListener(this));
               }
             });
             /*
              * 1 - registers a callback which copies the csrf token into the
              * X-CSRF-Token header with each ajax request.  Necessary to
              * work with rails applications which have fixed
              * CVE-2011-0447
              * 2 - shows and hides ajax indicator
              */
             Ajax.Responders.register({
                 onCreate: function(request){
                     var csrf_meta_tag = $$('meta[name=csrf-token]')[0];
                     if (csrf_meta_tag) {
                         var header = 'X-CSRF-Token',
                             token = csrf_meta_tag.readAttribute('content');
                         if (!request.options.requestHeaders) {
                           request.options.requestHeaders = {};
                         }
                         request.options.requestHeaders[header] = token;
                       }
                     if ($('ajax-indicator') && Ajax.activeRequestCount > 0) {
                         Element.show('ajax-indicator');
                     }
                 },
                 onComplete: function(){
                     if ($('ajax-indicator') && Ajax.activeRequestCount == 0) {
                         Element.hide('ajax-indicator');
                     }
                 }
             });
             function hideOnLoad() {
               $$('.hol').each(function(el) {
                 el.hide();
               });
             }
             Event.observe(window, 'load', hideOnLoad);

test/functional/versions_controller_test.rb +27 -3

             # Redmine - project management software
             # Copyright (C) 2006-2011  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             require 'versions_controller'
             # Re-raise errors caught by the controller.
             class VersionsController; def rescue_action(e) raise e end; end
             class VersionsControllerTest < ActionController::TestCase
               fixtures :projects, :versions, :issues, :users, :roles, :members, :member_roles, :enabled_modules, :issue_statuses
               def setup
                 @controller = VersionsController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
               def test_index
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:versions)
                 # Version with no date set appears
                 assert assigns(:versions).include?(Version.find(3))
                 # Completed version doesn't appear
                 assert !assigns(:versions).include?(Version.find(1))
                 # Context menu on issues
                 assert_select "script", :text => Regexp.new(Regexp.escape("new ContextMenu('/issues/context_menu')"))
                 # Links to versions anchors
                 assert_tag 'a', :attributes => {:href => '#2.0'},
                                 :ancestor => {:tag => 'div', :attributes => {:id => 'sidebar'}}
                 # Links to completed versions in the sidebar
                 assert_tag 'a', :attributes => {:href => '/versions/1'},
                                 :ancestor => {:tag => 'div', :attributes => {:id => 'sidebar'}}
               end
               def test_index_with_completed_versions
                 get :index, :project_id => 1, :completed => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:versions)
                 # Version with no date set appears
                 assert assigns(:versions).include?(Version.find(3))
                 # Completed version appears
                 assert assigns(:versions).include?(Version.find(1))
               end
               def test_index_with_tracker_ids
                 get :index, :project_id => 1, :tracker_ids => [1, 3]
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues_by_version)
                 assert_nil assigns(:issues_by_version).values.flatten.detect {|issue| issue.tracker_id == 2}
               end
               def test_index_showing_subprojects_versions
                 @subproject_version = Version.generate!(:project => Project.find(3))
                 get :index, :project_id => 1, :with_subprojects => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:versions)
                 assert assigns(:versions).include?(Version.find(4)), "Shared version not found"
                 assert assigns(:versions).include?(@subproject_version), "Subproject version not found"
               end
               def test_show
                 get :show, :id => 2
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:version)
                 assert_tag :tag => 'h2', :content => /1.0/
               end
               def test_new
                 @request.session[:user_id] = 2
                 get :new, :project_id => '1'
                 assert_response :success
                 assert_template 'new'
               end
+              def test_new_from_issue_form
+                @request.session[:user_id] = 2
+                xhr :get, :new, :project_id => '1'
+                assert_response :success
+                assert_select_rjs :replace_html, "ajax-modal" do
+                  assert_select "form[action=/projects/ecookbook/versions]"
+                  assert_select "input#version_name"
+                end
+              end
               def test_create
                 @request.session[:user_id] = 2 # manager
                 assert_difference 'Version.count' do
                   post :create, :project_id => '1', :version => {:name => 'test_add_version'}
                 end
                 assert_redirected_to '/projects/ecookbook/settings/versions'
                 version = Version.find_by_name('test_add_version')
                 assert_not_nil version
                 assert_equal 1, version.project_id
               end
               def test_create_from_issue_form
-                @request.session[:user_id] = 2 # manager
+                @request.session[:user_id] = 2
                 assert_difference 'Version.count' do
                   xhr :post, :create, :project_id => '1', :version => {:name => 'test_add_version_from_issue_form'}
                 end
-                assert_response :success
-                assert_select_rjs :replace, 'issue_fixed_version_id'
                 version = Version.find_by_name('test_add_version_from_issue_form')
                 assert_not_nil version
                 assert_equal 1, version.project_id
+                assert_response :success
+                assert_select_rjs :replace, 'issue_fixed_version_id' do
+                  assert_select "option[value=#{version.id}][selected=selected]"
+                end
+              end
+              def test_create_from_issue_form_with_failure
+                @request.session[:user_id] = 2
+                assert_no_difference 'Version.count' do
+                  xhr :post, :create, :project_id => '1', :version => {:name => ''}
+                end
+                assert_response :success
+                assert_select_rjs :replace_html, "ajax-modal" do
+                  assert_select "div#errorExplanation"
+                end
               end
               def test_get_edit
                 @request.session[:user_id] = 2
                 get :edit, :id => 2
                 assert_response :success
                 assert_template 'edit'
               end
               def test_close_completed
                 Version.update_all("status = 'open'")
                 @request.session[:user_id] = 2
                 put :close_completed, :project_id => 'ecookbook'
                 assert_redirected_to :controller => 'projects', :action => 'settings', :tab => 'versions', :id => 'ecookbook'
                 assert_not_nil Version.find_by_status('closed')
               end
               def test_post_update
                 @request.session[:user_id] = 2
                 put :update, :id => 2,
                             :version => { :name => 'New version name',
                                           :effective_date => Date.today.strftime("%Y-%m-%d")}
                 assert_redirected_to :controller => 'projects', :action => 'settings', :tab => 'versions', :id => 'ecookbook'
                 version = Version.find(2)
                 assert_equal 'New version name', version.name
                 assert_equal Date.today, version.effective_date
               end
               def test_post_update_with_validation_failure
                 @request.session[:user_id] = 2
                 put :update, :id => 2,
                              :version => { :name => '',
                                            :effective_date => Date.today.strftime("%Y-%m-%d")}
                 assert_response :success
                 assert_template 'edit'
               end
               def test_destroy
                 @request.session[:user_id] = 2
                 assert_difference 'Version.count', -1 do
                   delete :destroy, :id => 3
                 end
                 assert_redirected_to :controller => 'projects', :action => 'settings', :tab => 'versions', :id => 'ecookbook'
                 assert_nil Version.find_by_id(3)
               end
               def test_destroy_version_in_use_should_fail
                 @request.session[:user_id] = 2
                 assert_no_difference 'Version.count' do
                   delete :destroy, :id => 2
                 end
                 assert_redirected_to :controller => 'projects', :action => 'settings', :tab => 'versions', :id => 'ecookbook'
                 assert flash[:error].match(/Unable to delete version/)
                 assert Version.find_by_id(2)
               end
               def test_issue_status_by
                 xhr :get, :status_by, :id => 2
                 assert_response :success
                 assert_template '_issue_counts'
               end
               def test_issue_status_by_status
                 xhr :get, :status_by, :id => 2, :status_by => 'status'
                 assert_response :success
                 assert_template '_issue_counts'
               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