jro_apps/redmine Commit - r3199:68a4cd38f543

XML REST API for Projects (#296)....

Jean-Philippe Lang -

r3199:68a4cd38f543

parent child

Context file:

r3199:68a4cd38f543

Collapse all files

app/views/projects/index.xml.builder created 644 +18 0

@@ -0,0 +1,18
	1	xml.instruct!
	2	xml.projects :type => 'array' do
	3	@projects.each do \|project\|
	4	xml.project :id => project.id do
	5	xml.name project.name
	6	xml.identifier project.identifier
	7	xml.description project.description
	8	xml.parent(:id => project.parent_id, :name => project.parent.name) unless project.parent.nil?
	9	xml.custom_fields do
	10	project.custom_field_values.each do \|custom_value\|
	11	xml.custom_field custom_value.value, :id => custom_value.custom_field_id, :name => custom_value.custom_field.name
	12	end
	13	end unless project.custom_field_values.empty?
	14	xml.created_on project.created_on
	15	xml.updated_on project.updated_on
	16	end
	17	end
	18	end

app/views/projects/show.xml.builder created 644 +16 0

@@ -0,0 +1,16
	1	xml.instruct!
	2	xml.project :id => @project.id do
	3	xml.name @project.name
	4	xml.identifier @project.identifier
	5	xml.description @project.description
	6	xml.homepage @project.homepage
	7
	8	xml.custom_fields do
	9	@project.custom_field_values.each do \|custom_value\|
	10	xml.custom_field custom_value.value, :id => custom_value.custom_field_id, :name => custom_value.custom_field.name
	11	end
	12	end unless @project.custom_field_values.empty?
	13
	14	xml.created_on @project.created_on
	15	xml.updated_on @project.updated_on
	16	end

test/integration/projects_api_test.rb created 644 +134 0

@@ -0,0 +1,134
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2010 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	require "#{File.dirname(__FILE__)}/../test_helper"
	19
	20	class ProjectsApiTest < ActionController::IntegrationTest
	21	fixtures :projects, :versions, :users, :roles, :members, :member_roles, :issues, :journals, :journal_details,
	22	:trackers, :projects_trackers, :issue_statuses, :enabled_modules, :enumerations, :boards, :messages,
	23	:attachments, :custom_fields, :custom_values, :time_entries
	24
	25	def setup
	26	Setting.rest_api_enabled = '1'
	27	end
	28
	29	def test_index_routing
	30	assert_routing(
	31	{:method => :get, :path => '/projects.xml'},
	32	:controller => 'projects', :action => 'index', :format => 'xml'
	33	)
	34	end
	35
	36	def test_index
	37	get '/projects.xml'
	38	assert_response :success
	39	assert_equal 'application/xml', @response.content_type
	40	end
	41
	42	def test_show_routing
	43	assert_routing(
	44	{:method => :get, :path => '/projects/1.xml'},
	45	:controller => 'projects', :action => 'show', :id => '1', :format => 'xml'
	46	)
	47	end
	48
	49	def test_show
	50	get '/projects/1.xml'
	51	assert_response :success
	52	assert_equal 'application/xml', @response.content_type
	53	end
	54
	55	def test_create_routing
	56	assert_routing(
	57	{:method => :post, :path => '/projects.xml'},
	58	:controller => 'projects', :action => 'add', :format => 'xml'
	59	)
	60	end
	61
	62	def test_create
	63	attributes = {:name => 'API test', :identifier => 'api-test'}
	64	assert_difference 'Project.count' do
	65	post '/projects.xml', {:project => attributes}, :authorization => credentials('admin')
	66	end
	67	assert_response :created
	68	assert_equal 'application/xml', @response.content_type
	69	project = Project.first(:order => 'id DESC')
	70	attributes.each do \|attribute, value\|
	71	assert_equal value, project.send(attribute)
	72	end
	73	end
	74
	75	def test_create_failure
	76	attributes = {:name => 'API test'}
	77	assert_no_difference 'Project.count' do
	78	post '/projects.xml', {:project => attributes}, :authorization => credentials('admin')
	79	end
	80	assert_response :unprocessable_entity
	81	assert_equal 'application/xml', @response.content_type
	82	assert_tag :errors, :child => {:tag => 'error', :content => "Identifier can't be blank"}
	83	end
	84
	85	def test_update_routing
	86	assert_routing(
	87	{:method => :put, :path => '/projects/1.xml'},
	88	:controller => 'projects', :action => 'edit', :id => '1', :format => 'xml'
	89	)
	90	end
	91
	92	def test_update
	93	attributes = {:name => 'API update'}
	94	assert_no_difference 'Project.count' do
	95	put '/projects/1.xml', {:project => attributes}, :authorization => credentials('jsmith')
	96	end
	97	assert_response :ok
	98	assert_equal 'application/xml', @response.content_type
	99	project = Project.find(1)
	100	attributes.each do \|attribute, value\|
	101	assert_equal value, project.send(attribute)
	102	end
	103	end
	104
	105	def test_update_failure
	106	attributes = {:name => ''}
	107	assert_no_difference 'Project.count' do
	108	put '/projects/1.xml', {:project => attributes}, :authorization => credentials('jsmith')
	109	end
	110	assert_response :unprocessable_entity
	111	assert_equal 'application/xml', @response.content_type
	112	assert_tag :errors, :child => {:tag => 'error', :content => "Name can't be blank"}
	113	end
	114
	115	def test_destroy_routing
	116	assert_routing(
	117	{:method => :delete, :path => '/projects/1.xml'},
	118	:controller => 'projects', :action => 'destroy', :id => '1', :format => 'xml'
	119	)
	120	end
	121
	122	def test_destroy
	123	assert_difference 'Project.count', -1 do
	124	delete '/projects/2.xml', {}, :authorization => credentials('admin')
	125	end
	126	assert_response :ok
	127	assert_equal 'application/xml', @response.content_type
	128	assert_nil Project.find_by_id(2)
	129	end
	130
	131	def credentials(user, password=nil)
	132	ActionController::HttpAuthentication::Basic.encode_credentials(user, password \|\| user)
	133	end
	134	end

app/controllers/application_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.
             require 'uri'
             require 'cgi'
             class ApplicationController < ActionController::Base
               include Redmine::I18n
               layout 'base'
+              exempt_from_layout 'builder'
               # Remove broken cookie after upgrade from 0.8.x (#4292)
               # See https://rails.lighthouseapp.com/projects/8994/tickets/3360
               # TODO: remove it when Rails is fixed
               before_filter :delete_broken_cookies
               def delete_broken_cookies
                 if cookies['_redmine_session'] && cookies['_redmine_session'] !~ /--/
                   cookies.delete '_redmine_session'
                   redirect_to home_path
                   return false
                 end
               end
               before_filter :user_setup, :check_if_login_required, :set_localization
               filter_parameter_logging :password
               protect_from_forgery
               rescue_from ActionController::InvalidAuthenticityToken, :with => :invalid_authenticity_token
               include Redmine::Search::Controller
               include Redmine::MenuManager::MenuController
               helper Redmine::MenuManager::MenuHelper
               REDMINE_SUPPORTED_SCM.each do |scm|
                 require_dependency "repository/#{scm.underscore}"
               end
               def user_setup
                 # Check the settings cache for each request
                 Setting.check_cache
                 # Find the current user
                 User.current = find_current_user
               end
               # Returns the current user or nil if no user is logged in
               # and starts a session if needed
               def find_current_user
                 if session[:user_id]
                   # existing session
                   (User.active.find(session[:user_id]) rescue nil)
                 elsif cookies[:autologin] && Setting.autologin?
                   # auto-login feature starts a new session
                   user = User.try_to_autologin(cookies[:autologin])
                   session[:user_id] = user.id if user
                   user
                 elsif params[:format] == 'atom' && params[:key] && accept_key_auth_actions.include?(params[:action])
                   # RSS key authentication does not start a session
                   User.find_by_rss_key(params[:key])
                 elsif Setting.rest_api_enabled? && ['xml', 'json'].include?(params[:format])
                   if params[:key].present? && accept_key_auth_actions.include?(params[:action])
                     # Use API key
                     User.find_by_api_key(params[:key])
                   else
                     # HTTP Basic, either username/password or API key/random
                     authenticate_with_http_basic do |username, password|
                       User.try_to_login(username, password) || User.find_by_api_key(username)
                     end
                   end
                 end
               end
               # Sets the logged in user
               def logged_user=(user)
                 reset_session
                 if user && user.is_a?(User)
                   User.current = user
                   session[:user_id] = user.id
                 else
                   User.current = User.anonymous
                 end
               end
               # check if login is globally required to access the application
               def check_if_login_required
                 # no check needed if user is already logged in
                 return true if User.current.logged?
                 require_login if Setting.login_required?
               end
               def set_localization
                 lang = nil
                 if User.current.logged?
                   lang = find_language(User.current.language)
                 end
                 if lang.nil? && request.env['HTTP_ACCEPT_LANGUAGE']
                   accept_lang = parse_qvalues(request.env['HTTP_ACCEPT_LANGUAGE']).first.downcase
                   if !accept_lang.blank?
                     lang = find_language(accept_lang) || find_language(accept_lang.split('-').first)
                   end
                 end
                 lang ||= Setting.default_language
                 set_language_if_valid(lang)
               end
               def require_login
                 if !User.current.logged?
                   # Extract only the basic url parameters on non-GET requests
                   if request.get?
                     url = url_for(params)
                   else
                     url = url_for(:controller => params[:controller], :action => params[:action], :id => params[:id], :project_id => params[:project_id])
                   end
                   respond_to do |format|
                     format.html { redirect_to :controller => "account", :action => "login", :back_url => url }
                     format.atom { redirect_to :controller => "account", :action => "login", :back_url => url }
                     format.xml { head :unauthorized }
                     format.json { head :unauthorized }
                   end
                   return false
                 end
                 true
               end
               def require_admin
                 return unless require_login
                 if !User.current.admin?
                   render_403
                   return false
                 end
                 true
               end
               def deny_access
                 User.current.logged? ? render_403 : require_login
               end
               # Authorize the user for the requested action
               def authorize(ctrl = params[:controller], action = params[:action], global = false)
                 allowed = User.current.allowed_to?({:controller => ctrl, :action => action}, @project, :global => global)
                 allowed ? true : deny_access
               end
               # Authorize the user for the requested action outside a project
               def authorize_global(ctrl = params[:controller], action = params[:action], global = true)
                 authorize(ctrl, action, global)
               end
               # make sure that the user is a member of the project (or admin) if project is private
               # used as a before_filter for actions that do not require any particular permission on the project
               def check_project_privacy
                 if @project && @project.active?
                   if @project.is_public? || User.current.member_of?(@project) || User.current.admin?
                     true
                   else
                     User.current.logged? ? render_403 : require_login
                   end
                 else
                   @project = nil
                   render_404
                   false
                 end
               end
               def redirect_back_or_default(default)
                 back_url = CGI.unescape(params[:back_url].to_s)
                 if !back_url.blank?
                   begin
                     uri = URI.parse(back_url)
                     # do not redirect user to another host or to the login or register page
                     if (uri.relative? || (uri.host == request.host)) && !uri.path.match(%r{/(login|account/register)})
                       redirect_to(back_url)
                       return
                     end
                   rescue URI::InvalidURIError
                     # redirect to default
                   end
                 end
                 redirect_to default
               end
               def render_403
                 @project = nil
                 respond_to do |format|
                   format.html { render :template => "common/403", :layout => (request.xhr? ? false : 'base'), :status => 403 }
                   format.atom { head 403 }
                   format.xml { head 403 }
                   format.json { head 403 }
                 end
                 return false
               end
               def render_404
                 respond_to do |format|
                   format.html { render :template => "common/404", :layout => !request.xhr?, :status => 404 }
                   format.atom { head 404 }
                   format.xml { head 404 }
                   format.json { head 404 }
                 end
                 return false
               end
               def render_error(msg)
                 respond_to do |format|
                   format.html {
                     flash.now[:error] = msg
                     render :text => '', :layout => !request.xhr?, :status => 500
                   }
                   format.atom { head 500 }
                   format.xml { head 500 }
                   format.json { head 500 }
                 end
               end
               def invalid_authenticity_token
                 render_error "Invalid form authenticity token."
               end
               def render_feed(items, options={})
                 @items = items || []
                 @items.sort! {|x,y| y.event_datetime <=> x.event_datetime }
                 @items = @items.slice(0, Setting.feeds_limit.to_i)
                 @title = options[:title] || Setting.app_title
                 render :template => "common/feed.atom.rxml", :layout => false, :content_type => 'application/atom+xml'
               end
               def self.accept_key_auth(*actions)
                 actions = actions.flatten.map(&:to_s)
                 write_inheritable_attribute('accept_key_auth_actions', actions)
               end
               def accept_key_auth_actions
                 self.class.read_inheritable_attribute('accept_key_auth_actions') || []
               end
               # TODO: move to model
               def attach_files(obj, attachments)
                 attached = []
                 unsaved = []
                 if attachments && attachments.is_a?(Hash)
                   attachments.each_value do |attachment|
                     file = attachment['file']
                     next unless file && file.size > 0
                     a = Attachment.create(:container => obj,
                                           :file => file,
                                           :description => attachment['description'].to_s.strip,
                                           :author => User.current)
                     a.new_record? ? (unsaved << a) : (attached << a)
                   end
                   if unsaved.any?
                     flash[:warning] = l(:warning_attachments_not_saved, unsaved.size)
                   end
                 end
                 attached
               end
               # Returns the number of objects that should be displayed
               # on the paginated list
               def per_page_option
                 per_page = nil
                 if params[:per_page] && Setting.per_page_options_array.include?(params[:per_page].to_s.to_i)
                   per_page = params[:per_page].to_s.to_i
                   session[:per_page] = per_page
                 elsif session[:per_page]
                   per_page = session[:per_page]
                 else
                   per_page = Setting.per_page_options_array.first || 25
                 end
                 per_page
               end
               # qvalues http header parser
               # code taken from webrick
               def parse_qvalues(value)
                 tmp = []
                 if value
                   parts = value.split(/,\s*/)
                   parts.each {|part|
                     if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
                       val = m[1]
                       q = (m[2] or 1).to_f
                       tmp.push([val, q])
                     end
                   }
                   tmp = tmp.sort_by{|val, q| -q}
                   tmp.collect!{|val, q| val}
                 end
                 return tmp
               rescue
                 nil
               end
               # Returns a string that can be used as filename value in Content-Disposition header
               def filename_for_content_disposition(name)
                 request.env['HTTP_USER_AGENT'] =~ %r{MSIE} ? ERB::Util.url_encode(name) : name
               end
             end

app/controllers/projects_controller.rb +46 -10

             # 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.
             class ProjectsController < ApplicationController
               menu_item :overview
               menu_item :activity, :only => :activity
               menu_item :roadmap, :only => :roadmap
               menu_item :files, :only => [:list_files, :add_file]
               menu_item :settings, :only => :settings
               before_filter :find_project, :except => [ :index, :list, :add, :copy, :activity ]
               before_filter :find_optional_project, :only => :activity
               before_filter :authorize, :except => [ :index, :list, :add, :copy, :archive, :unarchive, :destroy, :activity ]
               before_filter :authorize_global, :only => :add
               before_filter :require_admin, :only => [ :copy, :archive, :unarchive, :destroy ]
               accept_key_auth :activity
               after_filter :only => [:add, :edit, :archive, :unarchive, :destroy] do |controller|
                 if controller.request.post?
                   controller.send :expire_action, :controller => 'welcome', :action => 'robots.txt'
                 end
               end
               helper :sort
               include SortHelper
               helper :custom_fields
               include CustomFieldsHelper
               helper :issues
               helper IssuesHelper
               helper :queries
               include QueriesHelper
               helper :repositories
               include RepositoriesHelper
               include ProjectsHelper
               # Lists visible projects
               def index
                 respond_to do |format|
                   format.html {
                     @projects = Project.visible.find(:all, :order => 'lft')
                   }
+                  format.xml  {
+                    @projects = Project.visible.find(:all, :order => 'lft')
+                  }
                   format.atom {
                     projects = Project.visible.find(:all, :order => 'created_on DESC',
                                                           :limit => Setting.feeds_limit.to_i)
                     render_feed(projects, :title => "#{Setting.app_title}: #{l(:label_project_latest)}")
                   }
                 end
               end
               # Add a new project
               def add
                 @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
                 @trackers = Tracker.all
                 @project = Project.new(params[:project])
                 if request.get?
                   @project.identifier = Project.next_identifier if Setting.sequential_project_identifiers?
                   @project.trackers = Tracker.all
                   @project.is_public = Setting.default_projects_public?
                   @project.enabled_module_names = Setting.default_projects_modules
                 else
                   @project.enabled_module_names = params[:enabled_modules]
                   if validate_parent_id && @project.save
                     @project.set_allowed_parent!(params[:project]['parent_id']) if params[:project].has_key?('parent_id')
                     # Add current user as a project member if he is not admin
                     unless User.current.admin?
                       r = Role.givable.find_by_id(Setting.new_project_user_role_id.to_i) || Role.givable.first
                       m = Member.new(:user => User.current, :roles => [r])
                       @project.members << m
                     end
-                    flash[:notice] = l(:notice_successful_create)
+                    respond_to do |format|
-                    redirect_to :controller => 'projects', :action => 'settings', :id => @project
+                      format.html {
+                        flash[:notice] = l(:notice_successful_create)
+                        redirect_to :controller => 'projects', :action => 'settings', :id => @project
+                      }
+                      format.xml  { head :created, :location => url_for(:controller => 'projects', :action => 'show', :id => @project.id) }
+                    end
+                  else
+                    respond_to do |format|
+                      format.html
+                      format.xml  { render :xml => @project.errors, :status => :unprocessable_entity }
+                    end
                   end
                 end
               end
               def copy
                 @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
                 @trackers = Tracker.all
                 @root_projects = Project.find(:all,
                                               :conditions => "parent_id IS NULL AND status = #{Project::STATUS_ACTIVE}",
                                               :order => 'name')
                 @source_project = Project.find(params[:id])
                 if request.get?
                   @project = Project.copy_from(@source_project)
                   if @project
                     @project.identifier = Project.next_identifier if Setting.sequential_project_identifiers?
                   else
                     redirect_to :controller => 'admin', :action => 'projects'
                   end
                 else
                   @project = Project.new(params[:project])
                   @project.enabled_module_names = params[:enabled_modules]
                   if validate_parent_id && @project.copy(@source_project, :only => params[:only])
                     @project.set_allowed_parent!(params[:project]['parent_id']) if params[:project].has_key?('parent_id')
                     flash[:notice] = l(:notice_successful_create)
                     redirect_to :controller => 'admin', :action => 'projects'
                   elsif !@project.new_record?
                     # Project was created
                     # But some objects were not copied due to validation failures
                     # (eg. issues from disabled trackers)
                     # TODO: inform about that
                     redirect_to :controller => 'admin', :action => 'projects'
                   end
                 end
               rescue ActiveRecord::RecordNotFound
                 redirect_to :controller => 'admin', :action => 'projects'
               end
               # Show @project
               def show
                 if params[:jump]
                   # try to redirect to the requested menu item
                   redirect_to_project_menu_item(@project, params[:jump]) && return
                 end
                 @users_by_role = @project.users_by_role
                 @subprojects = @project.children.visible
                 @news = @project.news.find(:all, :limit => 5, :include => [ :author, :project ], :order => "#{News.table_name}.created_on DESC")
                 @trackers = @project.rolled_up_trackers
                 cond = @project.project_condition(Setting.display_subprojects_issues?)
                 @open_issues_by_tracker = Issue.visible.count(:group => :tracker,
                                                         :include => [:project, :status, :tracker],
                                                         :conditions => ["(#{cond}) AND #{IssueStatus.table_name}.is_closed=?", false])
                 @total_issues_by_tracker = Issue.visible.count(:group => :tracker,
                                                         :include => [:project, :status, :tracker],
                                                         :conditions => cond)
                 TimeEntry.visible_by(User.current) do
                   @total_hours = TimeEntry.sum(:hours,
                                                :include => :project,
                                                :conditions => cond).to_f
                 end
                 @key = User.current.rss_key
+                respond_to do |format|
+                  format.html
+                  format.xml
+                end
               end
               def settings
                 @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
                 @issue_category ||= IssueCategory.new
                 @member ||= @project.members.new
                 @trackers = Tracker.all
                 @repository ||= @project.repository
                 @wiki ||= @project.wiki
               end
               # Edit @project
               def edit
-                if request.post?
+                if request.get?
+                else
                   @project.attributes = params[:project]
                   if validate_parent_id && @project.save
                     @project.set_allowed_parent!(params[:project]['parent_id']) if params[:project].has_key?('parent_id')
-                    flash[:notice] = l(:notice_successful_update)
+                    respond_to do |format|
-                    redirect_to :action => 'settings', :id => @project
+                      format.html {
+                        flash[:notice] = l(:notice_successful_update)
+                        redirect_to :action => 'settings', :id => @project
+                      }
+                      format.xml  { head :ok }
+                    end
                   else
-                    settings
+                    respond_to do |format|
-                    render :action => 'settings'
+                      format.html {
+                        settings
+                        render :action => 'settings'
+                      }
+                      format.xml  { render :xml => @project.errors, :status => :unprocessable_entity }
+                    end
                   end
                 end
               end
               def modules
                 @project.enabled_module_names = params[:enabled_modules]
                 redirect_to :action => 'settings', :id => @project, :tab => 'modules'
               end
               def archive
                 if request.post?
                   unless @project.archive
                     flash[:error] = l(:error_can_not_archive_project)
                   end
                 end
                 redirect_to(url_for(:controller => 'admin', :action => 'projects', :status => params[:status]))
               end
               def unarchive
                 @project.unarchive if request.post? && !@project.active?
                 redirect_to(url_for(:controller => 'admin', :action => 'projects', :status => params[:status]))
               end
               # Delete @project
               def destroy
                 @project_to_destroy = @project
-                if request.post? and params[:confirm]
+                if request.get?
-                  @project_to_destroy.destroy
+                  # display confirmation view
-                  redirect_to :controller => 'admin', :action => 'projects'
+                else
+                  if params[:format] == 'xml' || params[:confirm]
+                    @project_to_destroy.destroy
+                    respond_to do |format|
+                      format.html { redirect_to :controller => 'admin', :action => 'projects' }
+                      format.xml  { head :ok }
+                    end
+                  end
                 end
                 # hide project in layout
                 @project = nil
               end
               # Add a new issue category to @project
               def add_issue_category
                 @category = @project.issue_categories.build(params[:category])
                 if request.post?
                   if @category.save
                 	  respond_to do |format|
                       format.html do
                         flash[:notice] = l(:notice_successful_create)
                         redirect_to :action => 'settings', :tab => 'categories', :id => @project
                       end
                       format.js do
                         # IE doesn't support the replace_html rjs method for select box options
                         render(:update) {|page| page.replace "issue_category_id",
                           content_tag('select', '<option></option>' + options_from_collection_for_select(@project.issue_categories, 'id', 'name', @category.id), :id => 'issue_category_id', :name => 'issue[category_id]')
                         }
                       end
                     end
                   else
                     respond_to do |format|
                       format.html
                       format.js do
                         render(:update) {|page| page.alert(@category.errors.full_messages.join('\n')) }
                       end
                     end
                   end
                 end
               end
               # Add a new version to @project
               def add_version
                 @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_to :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| 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
                     end
                   else
                     respond_to do |format|
                       format.html
                       format.js do
                         render(:update) {|page| page.alert(@version.errors.full_messages.join('\n')) }
                       end
                     end
               	  end
               	end
               end
               def add_file
                 if request.post?
                   container = (params[:version_id].blank? ? @project : @project.versions.find_by_id(params[:version_id]))
                   attachments = attach_files(container, params[:attachments])
                   if !attachments.empty? && Setting.notified_events.include?('file_added')
                     Mailer.deliver_attachments_added(attachments)
                   end
                   redirect_to :controller => 'projects', :action => 'list_files', :id => @project
                   return
                 end
                 @versions = @project.versions.sort
               end
               def save_activities
                 if request.post? && params[:enumerations]
                   Project.transaction do
                     params[:enumerations].each do |id, activity|
                       @project.update_or_create_time_entry_activity(id, activity)
                     end
                   end
                 end
                 redirect_to :controller => 'projects', :action => 'settings', :tab => 'activities', :id => @project
               end
               def reset_activities
                 @project.time_entry_activities.each do |time_entry_activity|
                   time_entry_activity.destroy(time_entry_activity.parent)
                 end
                 redirect_to :controller => 'projects', :action => 'settings', :tab => 'activities', :id => @project
               end
               def list_files
                 sort_init 'filename', 'asc'
                 sort_update 'filename' => "#{Attachment.table_name}.filename",
                             'created_on' => "#{Attachment.table_name}.created_on",
                             'size' => "#{Attachment.table_name}.filesize",
                             'downloads' => "#{Attachment.table_name}.downloads"
                 @containers = [ Project.find(@project.id, :include => :attachments, :order => sort_clause)]
                 @containers += @project.versions.find(:all, :include => :attachments, :order => sort_clause).sort.reverse
                 render :layout => !request.xhr?
               end
               def roadmap
                 @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.sort
                 @versions.reject! {|version| version.closed? || version.completed? } unless params[:completed]
                 @issues_by_version = {}
                 unless @selected_tracker_ids.empty?
                   @versions.each do |version|
                     conditions = {:tracker_id => @selected_tracker_ids}
                     if !@project.versions.include?(version)
                       conditions.merge!(:project_id => project_ids)
                     end
                     issues = version.fixed_issues.visible.find(:all,
                                                                :include => [:project, :status, :tracker, :priority],
                                                                :conditions => conditions,
                                                                :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].empty?}
               end
               def activity
                 @days = Setting.activity_days_default.to_i
                 if params[:from]
                   begin; @date_to = params[:from].to_date + 1; rescue; end
                 end
                 @date_to ||= Date.today + 1
                 @date_from = @date_to - @days
                 @with_subprojects = params[:with_subprojects].nil? ? Setting.display_subprojects_issues? : (params[:with_subprojects] == '1')
                 @author = (params[:user_id].blank? ? nil : User.active.find(params[:user_id]))
                 @activity = Redmine::Activity::Fetcher.new(User.current, :project => @project,
                                                                          :with_subprojects => @with_subprojects,
                                                                          :author => @author)
                 @activity.scope_select {|t| !params["show_#{t}"].nil?}
                 @activity.scope = (@author.nil? ? :default : :all) if @activity.scope.empty?
                 events = @activity.events(@date_from, @date_to)
                 if events.empty? || stale?(:etag => [events.first, User.current])
                   respond_to do |format|
                     format.html {
                       @events_by_day = events.group_by(&:event_date)
                       render :layout => false if request.xhr?
                     }
                     format.atom {
                       title = l(:label_activity)
                       if @author
                         title = @author.name
                       elsif @activity.scope.size == 1
                         title = l("label_#{@activity.scope.first.singularize}_plural")
                       end
                       render_feed(events, :title => "#{@project || Setting.app_title}: #{title}")
                     }
                   end
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             private
               # Find project of id params[:id]
               # if not found, redirect to project list
               # Used as a before_filter
               def find_project
                 @project = Project.find(params[:id])
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_optional_project
                 return true unless params[:id]
                 @project = Project.find(params[:id])
                 authorize
               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
               # Validates parent_id param according to user's permissions
               # TODO: move it to Project model in a validation that depends on User.current
               def validate_parent_id
                 return true if User.current.admin?
                 parent_id = params[:project] && params[:project][:parent_id]
                 if parent_id || @project.new_record?
                   parent = parent_id.blank? ? nil : Project.find_by_id(parent_id.to_i)
                   unless @project.allowed_parents.include?(parent)
                     @project.errors.add :parent_id, :invalid
                     return false
                   end
                 end
                 true
               end
             end

config/routes.rb +7 0

             ActionController::Routing::Routes.draw do |map|
               # Add your own custom routes here.
               # The priority is based upon order of creation: first created -> highest priority.
               # Here's a sample route:
               # map.connect 'products/:id', :controller => 'catalog', :action => 'view'
               # Keep in mind you can assign values other than :controller and :action
               map.home '', :controller => 'welcome'
               map.signin 'login', :controller => 'account', :action => 'login'
               map.signout 'logout', :controller => 'account', :action => 'logout'
               map.connect 'roles/workflow/:id/:role_id/:tracker_id', :controller => 'roles', :action => 'workflow'
               map.connect 'help/:ctrl/:page', :controller => 'help'
               map.connect 'time_entries/:id/edit', :action => 'edit', :controller => 'timelog'
               map.connect 'projects/:project_id/time_entries/new', :action => 'edit', :controller => 'timelog'
               map.connect 'projects/:project_id/issues/:issue_id/time_entries/new', :action => 'edit', :controller => 'timelog'
               map.with_options :controller => 'timelog' do |timelog|
                 timelog.connect 'projects/:project_id/time_entries', :action => 'details'
                 timelog.with_options :action => 'details', :conditions => {:method => :get}  do |time_details|
                   time_details.connect 'time_entries'
                   time_details.connect 'time_entries.:format'
                   time_details.connect 'issues/:issue_id/time_entries'
                   time_details.connect 'issues/:issue_id/time_entries.:format'
                   time_details.connect 'projects/:project_id/time_entries.:format'
                   time_details.connect 'projects/:project_id/issues/:issue_id/time_entries'
                   time_details.connect 'projects/:project_id/issues/:issue_id/time_entries.:format'
                 end
                 timelog.connect 'projects/:project_id/time_entries/report', :action => 'report'
                 timelog.with_options :action => 'report',:conditions => {:method => :get} do |time_report|
                   time_report.connect 'time_entries/report'
                   time_report.connect 'time_entries/report.:format'
                   time_report.connect 'projects/:project_id/time_entries/report.:format'
                 end
                 timelog.with_options :action => 'edit', :conditions => {:method => :get} do |time_edit|
                   time_edit.connect 'issues/:issue_id/time_entries/new'
                 end
                 timelog.connect 'time_entries/:id/destroy', :action => 'destroy', :conditions => {:method => :post}
               end
               map.connect 'projects/:id/wiki', :controller => 'wikis', :action => 'edit', :conditions => {:method => :post}
               map.connect 'projects/:id/wiki/destroy', :controller => 'wikis', :action => 'destroy', :conditions => {:method => :get}
               map.connect 'projects/:id/wiki/destroy', :controller => 'wikis', :action => 'destroy', :conditions => {:method => :post}
               map.with_options :controller => 'wiki' do |wiki_routes|
                 wiki_routes.with_options :conditions => {:method => :get} do |wiki_views|
                   wiki_views.connect 'projects/:id/wiki/:page', :action => 'special', :page => /page_index|date_index|export/i
                   wiki_views.connect 'projects/:id/wiki/:page', :action => 'index', :page => nil
                   wiki_views.connect 'projects/:id/wiki/:page/edit', :action => 'edit'
                   wiki_views.connect 'projects/:id/wiki/:page/rename', :action => 'rename'
                   wiki_views.connect 'projects/:id/wiki/:page/history', :action => 'history'
                   wiki_views.connect 'projects/:id/wiki/:page/diff/:version/vs/:version_from', :action => 'diff'
                   wiki_views.connect 'projects/:id/wiki/:page/annotate/:version', :action => 'annotate'
                 end
                 wiki_routes.connect 'projects/:id/wiki/:page/:action',
                   :action => /edit|rename|destroy|preview|protect/,
                   :conditions => {:method => :post}
               end
               map.with_options :controller => 'messages' do |messages_routes|
                 messages_routes.with_options :conditions => {:method => :get} do |messages_views|
                   messages_views.connect 'boards/:board_id/topics/new', :action => 'new'
                   messages_views.connect 'boards/:board_id/topics/:id', :action => 'show'
                   messages_views.connect 'boards/:board_id/topics/:id/edit', :action => 'edit'
                 end
                 messages_routes.with_options :conditions => {:method => :post} do |messages_actions|
                   messages_actions.connect 'boards/:board_id/topics/new', :action => 'new'
                   messages_actions.connect 'boards/:board_id/topics/:id/replies', :action => 'reply'
                   messages_actions.connect 'boards/:board_id/topics/:id/:action', :action => /edit|destroy/
                 end
               end
               map.with_options :controller => 'boards' do |board_routes|
                 board_routes.with_options :conditions => {:method => :get} do |board_views|
                   board_views.connect 'projects/:project_id/boards', :action => 'index'
                   board_views.connect 'projects/:project_id/boards/new', :action => 'new'
                   board_views.connect 'projects/:project_id/boards/:id', :action => 'show'
                   board_views.connect 'projects/:project_id/boards/:id.:format', :action => 'show'
                   board_views.connect 'projects/:project_id/boards/:id/edit', :action => 'edit'
                 end
                 board_routes.with_options :conditions => {:method => :post} do |board_actions|
                   board_actions.connect 'projects/:project_id/boards', :action => 'new'
                   board_actions.connect 'projects/:project_id/boards/:id/:action', :action => /edit|destroy/
                 end
               end
               map.with_options :controller => 'documents' do |document_routes|
                 document_routes.with_options :conditions => {:method => :get} do |document_views|
                   document_views.connect 'projects/:project_id/documents', :action => 'index'
                   document_views.connect 'projects/:project_id/documents/new', :action => 'new'
                   document_views.connect 'documents/:id', :action => 'show'
                   document_views.connect 'documents/:id/edit', :action => 'edit'
                 end
                 document_routes.with_options :conditions => {:method => :post} do |document_actions|
                   document_actions.connect 'projects/:project_id/documents', :action => 'new'
                   document_actions.connect 'documents/:id/:action', :action => /destroy|edit/
                 end
               end
               map.with_options :controller => 'issues' do |issues_routes|
                 issues_routes.with_options :conditions => {:method => :get} do |issues_views|
                   issues_views.connect 'issues', :action => 'index'
                   issues_views.connect 'issues.:format', :action => 'index'
                   issues_views.connect 'projects/:project_id/issues', :action => 'index'
                   issues_views.connect 'projects/:project_id/issues.:format', :action => 'index'
                   issues_views.connect 'projects/:project_id/issues/new', :action => 'new'
                   issues_views.connect 'projects/:project_id/issues/gantt', :action => 'gantt'
                   issues_views.connect 'projects/:project_id/issues/calendar', :action => 'calendar'
                   issues_views.connect 'projects/:project_id/issues/:copy_from/copy', :action => 'new'
                   issues_views.connect 'issues/:id', :action => 'show', :id => /\d+/
                   issues_views.connect 'issues/:id.:format', :action => 'show', :id => /\d+/
                   issues_views.connect 'issues/:id/edit', :action => 'edit', :id => /\d+/
                   issues_views.connect 'issues/:id/move', :action => 'move', :id => /\d+/
                 end
                 issues_routes.with_options :conditions => {:method => :post} do |issues_actions|
                   issues_actions.connect 'issues', :action => 'index'
                   issues_actions.connect 'projects/:project_id/issues', :action => 'new'
                   issues_actions.connect 'issues/:id/quoted', :action => 'reply', :id => /\d+/
                   issues_actions.connect 'issues/:id/:action', :action => /edit|move|destroy/, :id => /\d+/
                   issues_actions.connect 'issues.:format', :action => 'new', :format => /xml/
                 end
                 issues_routes.with_options :conditions => {:method => :put} do |issues_actions|
                   issues_actions.connect 'issues/:id.:format', :action => 'edit', :id => /\d+/, :format => /xml/
                 end
                 issues_routes.with_options :conditions => {:method => :delete} do |issues_actions|
                   issues_actions.connect 'issues/:id.:format', :action => 'destroy', :id => /\d+/, :format => /xml/
                 end
                 issues_routes.connect 'issues/:action'
               end
               map.with_options  :controller => 'issue_relations', :conditions => {:method => :post} do |relations|
                 relations.connect 'issues/:issue_id/relations/:id', :action => 'new'
                 relations.connect 'issues/:issue_id/relations/:id/destroy', :action => 'destroy'
               end
               map.with_options :controller => 'reports', :action => 'issue_report', :conditions => {:method => :get} do |reports|
                 reports.connect 'projects/:id/issues/report'
                 reports.connect 'projects/:id/issues/report/:detail'
               end
               map.with_options :controller => 'news' do |news_routes|
                 news_routes.with_options :conditions => {:method => :get} do |news_views|
                   news_views.connect 'news', :action => 'index'
                   news_views.connect 'projects/:project_id/news', :action => 'index'
                   news_views.connect 'projects/:project_id/news.:format', :action => 'index'
                   news_views.connect 'news.:format', :action => 'index'
                   news_views.connect 'projects/:project_id/news/new', :action => 'new'
                   news_views.connect 'news/:id', :action => 'show'
                   news_views.connect 'news/:id/edit', :action => 'edit'
                 end
                 news_routes.with_options do |news_actions|
                   news_actions.connect 'projects/:project_id/news', :action => 'new'
                   news_actions.connect 'news/:id/edit', :action => 'edit'
                   news_actions.connect 'news/:id/destroy', :action => 'destroy'
                 end
               end
               map.connect 'projects/:id/members/new', :controller => 'members', :action => 'new'
               map.with_options :controller => 'users' do |users|
                 users.with_options :conditions => {:method => :get} do |user_views|
                   user_views.connect 'users', :action => 'index'
                   user_views.connect 'users/:id', :action => 'show', :id => /\d+/
                   user_views.connect 'users/new', :action => 'add'
                   user_views.connect 'users/:id/edit/:tab', :action => 'edit', :tab => nil
                 end
                 users.with_options :conditions => {:method => :post} do |user_actions|
                   user_actions.connect 'users', :action => 'add'
                   user_actions.connect 'users/new', :action => 'add'
                   user_actions.connect 'users/:id/edit', :action => 'edit'
                   user_actions.connect 'users/:id/memberships', :action => 'edit_membership'
                   user_actions.connect 'users/:id/memberships/:membership_id', :action => 'edit_membership'
                   user_actions.connect 'users/:id/memberships/:membership_id/destroy', :action => 'destroy_membership'
                 end
               end
               map.with_options :controller => 'projects' do |projects|
                 projects.with_options :conditions => {:method => :get} do |project_views|
                   project_views.connect 'projects', :action => 'index'
                   project_views.connect 'projects.:format', :action => 'index'
                   project_views.connect 'projects/new', :action => 'add'
                   project_views.connect 'projects/:id', :action => 'show'
+                  project_views.connect 'projects/:id.:format', :action => 'show'
                   project_views.connect 'projects/:id/:action', :action => /roadmap|destroy|settings/
                   project_views.connect 'projects/:id/files', :action => 'list_files'
                   project_views.connect 'projects/:id/files/new', :action => 'add_file'
                   project_views.connect 'projects/:id/versions/new', :action => 'add_version'
                   project_views.connect 'projects/:id/categories/new', :action => 'add_issue_category'
                   project_views.connect 'projects/:id/settings/:tab', :action => 'settings'
                 end
                 projects.with_options :action => 'activity', :conditions => {:method => :get} do |activity|
                   activity.connect 'projects/:id/activity'
                   activity.connect 'projects/:id/activity.:format'
                   activity.connect 'activity', :id => nil
                   activity.connect 'activity.:format', :id => nil
                 end
                 projects.with_options :conditions => {:method => :post} do |project_actions|
                   project_actions.connect 'projects/new', :action => 'add'
                   project_actions.connect 'projects', :action => 'add'
+                  project_actions.connect 'projects.:format', :action => 'add', :format => /xml/
                   project_actions.connect 'projects/:id/:action', :action => /destroy|archive|unarchive/
                   project_actions.connect 'projects/:id/files/new', :action => 'add_file'
                   project_actions.connect 'projects/:id/versions/new', :action => 'add_version'
                   project_actions.connect 'projects/:id/categories/new', :action => 'add_issue_category'
                   project_actions.connect 'projects/:id/activities/save', :action => 'save_activities'
                 end
+                projects.with_options :conditions => {:method => :put} do |project_actions|
+                  project_actions.conditions 'projects/:id.:format', :action => 'edit', :format => /xml/
+                end
                 projects.with_options :conditions => {:method => :delete} do |project_actions|
+                  project_actions.conditions 'projects/:id.:format', :action => 'destroy', :format => /xml/
                   project_actions.conditions 'projects/:id/reset_activities', :action => 'reset_activities'
                 end
               end
               map.with_options :controller => 'versions' do |versions|
                 versions.with_options :conditions => {:method => :post} do |version_actions|
                   version_actions.connect 'projects/:project_id/versions/close_completed', :action => 'close_completed'
                 end
               end
               map.with_options :controller => 'repositories' do |repositories|
                 repositories.with_options :conditions => {:method => :get} do |repository_views|
                   repository_views.connect 'projects/:id/repository', :action => 'show'
                   repository_views.connect 'projects/:id/repository/edit', :action => 'edit'
                   repository_views.connect 'projects/:id/repository/statistics', :action => 'stats'
                   repository_views.connect 'projects/:id/repository/revisions', :action => 'revisions'
                   repository_views.connect 'projects/:id/repository/revisions.:format', :action => 'revisions'
                   repository_views.connect 'projects/:id/repository/revisions/:rev', :action => 'revision'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/diff', :action => 'diff'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/diff.:format', :action => 'diff'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/raw/*path', :action => 'entry', :format => 'raw', :requirements => { :rev => /[a-z0-9\.\-_]+/ }
                   repository_views.connect 'projects/:id/repository/revisions/:rev/:action/*path', :requirements => { :rev => /[a-z0-9\.\-_]+/ }
                   repository_views.connect 'projects/:id/repository/raw/*path', :action => 'entry', :format => 'raw'
                   # TODO: why the following route is required?
                   repository_views.connect 'projects/:id/repository/entry/*path', :action => 'entry'
                   repository_views.connect 'projects/:id/repository/:action/*path'
                 end
                 repositories.connect 'projects/:id/repository/:action', :conditions => {:method => :post}
               end
               map.connect 'attachments/:id', :controller => 'attachments', :action => 'show', :id => /\d+/
               map.connect 'attachments/:id/:filename', :controller => 'attachments', :action => 'show', :id => /\d+/, :filename => /.*/
               map.connect 'attachments/download/:id/:filename', :controller => 'attachments', :action => 'download', :id => /\d+/, :filename => /.*/
               map.resources :groups
               #left old routes at the bottom for backwards compat
               map.connect 'projects/:project_id/issues/:action', :controller => 'issues'
               map.connect 'projects/:project_id/documents/:action', :controller => 'documents'
               map.connect 'projects/:project_id/boards/:action/:id', :controller => 'boards'
               map.connect 'boards/:board_id/topics/:action/:id', :controller => 'messages'
               map.connect 'wiki/:id/:page/:action', :page => nil, :controller => 'wiki'
               map.connect 'issues/:issue_id/relations/:action/:id', :controller => 'issue_relations'
               map.connect 'projects/:project_id/news/:action', :controller => 'news'
               map.connect 'projects/:project_id/timelog/:action/:id', :controller => 'timelog', :project_id => /.+/
               map.with_options :controller => 'repositories' do |omap|
                 omap.repositories_show 'repositories/browse/:id/*path', :action => 'browse'
                 omap.repositories_changes 'repositories/changes/:id/*path', :action => 'changes'
                 omap.repositories_diff 'repositories/diff/:id/*path', :action => 'diff'
                 omap.repositories_entry 'repositories/entry/:id/*path', :action => 'entry'
                 omap.repositories_entry 'repositories/annotate/:id/*path', :action => 'annotate'
                 omap.connect 'repositories/revision/:id/:rev', :action => 'revision'
               end
               map.with_options :controller => 'sys' do |sys|
                 sys.connect 'sys/projects.:format', :action => 'projects', :conditions => {:method => :get}
                 sys.connect 'sys/projects/:id/repository.:format', :action => 'create_project_repository', :conditions => {:method => :post}
               end
               # Install the default route as the lowest priority.
               map.connect ':controller/:action/:id'
               map.connect 'robots.txt', :controller => 'welcome', :action => 'robots'
               # Used for OpenID
               map.root :controller => 'account', :action => 'login'
             end

test/fixtures/custom_fields.yml +1 -1

             ---
             custom_fields_001:
               name: Database
               min_length: 0
               regexp: ""
               is_for_all: true
               is_filter: true
               type: IssueCustomField
               max_length: 0
               possible_values:
               - MySQL
               - PostgreSQL
               - Oracle
               id: 1
               is_required: false
               field_format: list
               default_value: ""
               editable: true
             custom_fields_002:
               name: Searchable field
               min_length: 1
               regexp: ""
               is_for_all: true
               type: IssueCustomField
               max_length: 100
               possible_values: ""
               id: 2
               is_required: false
               field_format: string
               searchable: true
               default_value: "Default string"
               editable: true
             custom_fields_003:
               name: Development status
               min_length: 0
               regexp: ""
               is_for_all: false
               is_filter: true
               type: ProjectCustomField
               max_length: 0
               possible_values:
               - Stable
               - Beta
               - Alpha
               - Planning
               id: 3
-              is_required: true
+              is_required: false
               field_format: list
               default_value: ""
               editable: true
             custom_fields_004:
               name: Phone number
               min_length: 0
               regexp: ""
               is_for_all: false
               type: UserCustomField
               max_length: 0
               possible_values: ""
               id: 4
               is_required: false
               field_format: string
               default_value: ""
               editable: true
             custom_fields_005:
               name: Money
               min_length: 0
               regexp: ""
               is_for_all: false
               type: UserCustomField
               max_length: 0
               possible_values: ""
               id: 5
               is_required: false
               field_format: float
               default_value: ""
               editable: true
             custom_fields_006:
               name: Float field
               min_length: 0
               regexp: ""
               is_for_all: true
               type: IssueCustomField
               max_length: 0
               possible_values: ""
               id: 6
               is_required: false
               field_format: float
               default_value: ""
               editable: true
             custom_fields_007:
               name: Billable
               min_length: 0
               regexp: ""
               is_for_all: false
               is_filter: true
               type: TimeEntryActivityCustomField
               max_length: 0
               possible_values: ""
               id: 7
               is_required: false
               field_format: bool
               default_value: ""
               editable: true
             custom_fields_008:
               name: Custom date
               min_length: 0
               regexp: ""
               is_for_all: true
               is_filter: false
               type: IssueCustomField
               max_length: 0
               possible_values: ""
               id: 8
               is_required: false
               field_format: date
               default_value: ""
               editable: true
             custom_fields_009:
               name: Project 1 cf
               min_length: 0
               regexp: ""
               is_for_all: false
               is_filter: true
               type: IssueCustomField
               max_length: 0
               possible_values: ""
               id: 9
               is_required: false
               field_format: date
               default_value: ""
               editable: true

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