Redmine

# Add your own tasks in files placed in lib/tasks ending in .rake,

# for example lib/tasks/switchtower.rake, and they will automatically be available to Rake.

require(File.join(File.dirname(__FILE__), 'config', 'boot'))

require 'rake'

require 'rake/testtask'

require 'rake/rdoctask'

require 'tasks/rails'

# redMine - project management software

# Copyright (C) 2006-2007  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class SysApi < ActionWebService::API::Base

  api_method :projects,

             :expects => [],

             :returns => [[Project]]

  api_method :repository_created,

             :expects => [:string, :string],

             :returns => [:int]

end

# redMine - project management software

# Copyright (C) 2006-2007  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class AccountController < ApplicationController

  layout 'base'	

  helper :custom_fields

  include CustomFieldsHelper   

  # prevents login action to be filtered by check_if_login_required application scope filter

  skip_before_filter :check_if_login_required, :only => [:login, :lost_password, :register, :activate]

  # Show user's account

  def show

    @user = User.find_active(params[:id])

    @custom_values = @user.custom_values.find(:all, :include => :custom_field)

    # show only public projects and private projects that the logged in user is also a member of

    @memberships = @user.memberships.select do |membership|

      membership.project.is_public? || (User.current.member_of?(membership.project))

    end

  rescue ActiveRecord::RecordNotFound

    render_404

  end

  # Login request and validation

  def login

    if request.get?

      # Logout user

      self.logged_user = nil

    else

      # Authenticate user

      user = User.try_to_login(params[:username], params[:password])

      if user

        self.logged_user = user

        # generate a key and set cookie if autologin

        if params[:autologin] && Setting.autologin?

          token = Token.create(:user => user, :action => 'autologin')

          cookies[:autologin] = { :value => token.value, :expires => 1.year.from_now }

        end

        redirect_back_or_default :controller => 'my', :action => 'page'

      else

        flash.now[:error] = l(:notice_account_invalid_creditentials)

      end

    end

  end

  # Log out current user and redirect to welcome page

  def logout

    cookies.delete :autologin

    Token.delete_all(["user_id = ? AND action = ?", User.current.id, 'autologin']) if User.current.logged?

    self.logged_user = nil

    redirect_to home_url

  end

  # Enable user to choose a new password

  def lost_password

    redirect_to(home_url) && return unless Setting.lost_password?

    if params[:token]

      @token = Token.find_by_action_and_value("recovery", params[:token])

      redirect_to(home_url) && return unless @token and [email protected]?

      @user = @token.user

      if request.post?

        @user.password, @user.password_confirmation = params[:new_password], params[:new_password_confirmation]

        if @user.save

          @token.destroy

          flash[:notice] = l(:notice_account_password_updated)

          redirect_to :action => 'login'

          return

        end 

      end

      render :template => "account/password_recovery"

      return

    else

      if request.post?

        user = User.find_by_mail(params[:mail])

        # user not found in db

        flash.now[:error] = l(:notice_account_unknown_email) and return unless user

        # user uses an external authentification

        flash.now[:error] = l(:notice_can_t_change_password) and return if user.auth_source_id

        # create a new token for password recovery

        token = Token.new(:user => user, :action => "recovery")

        if token.save

          Mailer.deliver_lost_password(token)

          flash[:notice] = l(:notice_account_lost_email_sent)

          redirect_to :action => 'login'

          return

        end

      end

    end

  end

  # User self-registration

  def register

    redirect_to(home_url) && return unless Setting.self_registration?

    if request.get?

      @user = User.new(:language => Setting.default_language)

      @custom_values = UserCustomField.find(:all).collect { |x| CustomValue.new(:custom_field => x, :customized => @user) }

    else

      @user = User.new(params[:user])

      @user.admin = false

      @user.login = params[:user][:login]

      @user.status = User::STATUS_REGISTERED

      @user.password, @user.password_confirmation = params[:password], params[:password_confirmation]

      @custom_values = UserCustomField.find(:all).collect { |x| CustomValue.new(:custom_field => x, 

                                                                                :customized => @user, 

                                                                                :value => (params["custom_fields"] ? params["custom_fields"][x.id.to_s] : nil)) }

      @user.custom_values = @custom_values

      case Setting.self_registration

      when '1'

        # Email activation

        token = Token.new(:user => @user, :action => "register")

        if @user.save and token.save

          Mailer.deliver_register(token)

          flash[:notice] = l(:notice_account_register_done)

          redirect_to :action => 'login'

        end

      when '3'

        # Automatic activation

        @user.status = User::STATUS_ACTIVE

        if @user.save

          flash[:notice] = l(:notice_account_activated)

          redirect_to :action => 'login'

        end

      else

        # Manual activation by the administrator

        if @user.save

          # Sends an email to the administrators

          Mailer.deliver_account_activation_request(@user)

          flash[:notice] = l(:notice_account_pending)

          redirect_to :action => 'login'

        end

      end

    end

  end

  # Token based account activation

  def activate

    redirect_to(home_url) && return unless Setting.self_registration? && params[:token]

    token = Token.find_by_action_and_value('register', params[:token])

    redirect_to(home_url) && return unless token and !token.expired?

    user = token.user

    redirect_to(home_url) && return unless user.status == User::STATUS_REGISTERED

    user.status = User::STATUS_ACTIVE

    if user.save

      token.destroy

      flash[:notice] = l(:notice_account_activated)

    end

    redirect_to :action => 'login'

  end

private

  def logged_user=(user)

    if user && user.is_a?(User)

      User.current = user

      session[:user_id] = user.id

    else

      User.current = User.anonymous

      session[:user_id] = nil

    end

  end

end

# redMine - project management software

# Copyright (C) 2006  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 AdminController < ApplicationController

  layout 'base'	

  before_filter :require_admin

  helper :sort

  include SortHelper	

  def index

    @no_configuration_data = Redmine::DefaultData::Loader::no_data?

  end

  def projects

    sort_init 'name', 'asc'

    sort_update

    @status = params[:status] ? params[:status].to_i : 0

    conditions = nil

    conditions = ["status=?", @status] unless @status == 0

    @project_count = Project.count(:conditions => conditions)

    @project_pages = Paginator.new self, @project_count,

								per_page_option,

								params['page']								

    @projects = Project.find :all, :order => sort_clause,

                        :conditions => conditions,

						:limit  =>  @project_pages.items_per_page,

						:offset =>  @project_pages.current.offset

    render :action => "projects", :layout => false if request.xhr?

  end

  # Loads the default configuration

  # (roles, trackers, statuses, workflow, enumerations)

  def default_configuration

    if request.post?

      begin

        Redmine::DefaultData::Loader::load(params[:lang])

        flash[:notice] = l(:notice_default_data_loaded)

      rescue Exception => e

        flash[:error] = l(:error_can_t_load_default_data, e.message)

      end

    end

    redirect_to :action => 'index'

  end

  def test_email

    raise_delivery_errors = ActionMailer::Base.raise_delivery_errors

    # Force ActionMailer to raise delivery errors so we can catch it

    ActionMailer::Base.raise_delivery_errors = true

    begin

      @test = Mailer.deliver_test(User.current)

      flash[:notice] = l(:notice_email_sent, User.current.mail)

    rescue Exception => e

      flash[:error] = l(:notice_email_error, e.message)

    end

    ActionMailer::Base.raise_delivery_errors = raise_delivery_errors

    redirect_to :controller => 'settings', :action => 'edit', :tab => 'notifications'

  end

  def info

    @db_adapter_name = ActiveRecord::Base.connection.adapter_name

    @flags = {

      :default_admin_changed => User.find(:first, :conditions => ["login=? and hashed_password=?", 'admin', User.hash_password('admin')]).nil?,

      :file_repository_writable => File.writable?(Attachment.storage_path),

      :rmagick_available => Object.const_defined?(:Magick)

    }

    @plugins = Redmine::Plugin.registered_plugins

  end  

end

# redMine - project management software

# Copyright (C) 2006-2007  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class ApplicationController < ActionController::Base

  before_filter :user_setup, :check_if_login_required, :set_localization

  filter_parameter_logging :password

  include Redmine::MenuManager::MenuController

  helper Redmine::MenuManager::MenuHelper

  REDMINE_SUPPORTED_SCM.each do |scm|

    require_dependency "repository/#{scm.underscore}"

  end

  def current_role

    @current_role ||= User.current.role_for_project(@project)

  end

  def user_setup

    # 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

  def find_current_user

    if session[:user_id]

      # existing session

      (User.find_active(session[:user_id]) rescue nil)

    elsif cookies[:autologin] && Setting.autologin?

      # auto-login feature

      User.find_by_autologin_key(cookies[:autologin])

    elsif params[:key] && accept_key_auth_actions.include?(params[:action])

      # RSS key authentication

      User.find_by_rss_key(params[:key])

    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

    User.current.language = nil unless User.current.logged?

    lang = begin

      if !User.current.language.blank? and GLoc.valid_languages.include? User.current.language.to_sym

        User.current.language

      elsif request.env['HTTP_ACCEPT_LANGUAGE']

        accept_lang = parse_qvalues(request.env['HTTP_ACCEPT_LANGUAGE']).first.split('-').first

        if accept_lang and !accept_lang.empty? and GLoc.valid_languages.include? accept_lang.to_sym

          User.current.language = accept_lang

        end

      end

    rescue

      nil

    end || Setting.default_language

    set_language_if_valid(lang)    

  end

  def require_login

    if !User.current.logged?

      store_location

      redirect_to :controller => "account", :action => "login"

      return false

    end

    true

  end

  def require_admin

    return unless require_login

    if !User.current.admin?

      render_403

      return false

    end

    true

  end

  # Authorize the user for the requested action

  def authorize(ctrl = params[:controller], action = params[:action])

    allowed = User.current.allowed_to?({:controller => ctrl, :action => action}, @project)

    allowed ? true : (User.current.logged? ? render_403 : require_login)

  end

  # make sure that the user is a member of the project (or admin) if project is private

  # used as a before_filter for actions that do not require any particular permission on the project

  def check_project_privacy

    unless @project.active?

      @project = nil

      render_404

      return false

    end

    return true if @project.is_public? || User.current.member_of?(@project) || User.current.admin?

    User.current.logged? ? render_403 : require_login

  end

  # store current uri in session.

  # return to this location by calling redirect_back_or_default

  def store_location

    session[:return_to_params] = params

  end

  # move to the last store_location call or to the passed default one

  def redirect_back_or_default(default)

    if session[:return_to_params].nil?

      redirect_to default

    else

      redirect_to session[:return_to_params]

      session[:return_to_params] = nil

    end

  end

  def render_403

    @project = nil

    render :template => "common/403", :layout => !request.xhr?, :status => 403

    return false

  end

  def render_404

    render :template => "common/404", :layout => !request.xhr?, :status => 404

    return false

  end

  def render_error(msg)

    flash.now[:error] = msg

    render :nothing => true, :layout => !request.xhr?, :status => 500

  end

  def render_feed(items, options={})    

    @items = items || []

    @items.sort! {|x,y| y.event_datetime <=> x.event_datetime }

    @title = options[:title] || Setting.app_title

    render :template => "common/feed.atom.rxml", :layout => false, :content_type => 'application/atom+xml'

  end

  def self.accept_key_auth(*actions)

    actions = actions.flatten.map(&:to_s)

    write_inheritable_attribute('accept_key_auth_actions', actions)

  end

  def accept_key_auth_actions

    self.class.read_inheritable_attribute('accept_key_auth_actions') || []

  end

  # TODO: move to model

  def attach_files(obj, attachments)

    attached = []

    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)

        attached << a unless a.new_record?

      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

  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

# redMine - project management software

# Copyright (C) 2006-2007  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class AttachmentsController < ApplicationController

  layout 'base'

  before_filter :find_project, :check_project_privacy

  def download

    # images are sent inline

    send_file @attachment.diskfile, :filename => filename_for_content_disposition(@attachment.filename),

                                    :type => @attachment.content_type, 

                                    :disposition => (@attachment.image? ? 'inline' : 'attachment')

  rescue

    # in case the disk file was deleted

    render_404

  end

private

  def find_project

    @attachment = Attachment.find(params[:id])

    @project = @attachment.project

  rescue

    render_404

  end

end

# redMine - project management software

# Copyright (C) 2006  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 AuthSourcesController < ApplicationController

  layout 'base'	

  before_filter :require_admin

  def index

    list

    render :action => 'list' unless request.xhr?

  end

  # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)

  verify :method => :post, :only => [ :destroy, :create, :update ],

         :redirect_to => { :action => :list }

  def list

    @auth_source_pages, @auth_sources = paginate :auth_sources, :per_page => 10

    render :action => "list", :layout => false if request.xhr?

  end

  def new

    @auth_source = AuthSourceLdap.new

  end

  def create

    @auth_source = AuthSourceLdap.new(params[:auth_source])

    if @auth_source.save

      flash[:notice] = l(:notice_successful_create)

      redirect_to :action => 'list'

    else

      render :action => 'new'

    end

  end

  def edit

    @auth_source = AuthSource.find(params[:id])

  end

  def update

    @auth_source = AuthSource.find(params[:id])

    if @auth_source.update_attributes(params[:auth_source])

      flash[:notice] = l(:notice_successful_update)

      redirect_to :action => 'list'

    else

      render :action => 'edit'

    end

  end

  def test_connection

    @auth_method = AuthSource.find(params[:id])

    begin

      @auth_method.test_connection

      flash[:notice] = l(:notice_successful_connection)

    rescue => text

      flash[:error] = "Unable to connect (#{text})"

    end

    redirect_to :action => 'list'

  end

  def destroy

    @auth_source = AuthSource.find(params[:id])

    unless @auth_source.users.find(:first)

      @auth_source.destroy

      flash[:notice] = l(:notice_successful_delete)

    end

    redirect_to :action => 'list'

  end

end

# redMine - project management software

# Copyright (C) 2006-2007  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class BoardsController < ApplicationController

  layout 'base'

  before_filter :find_project, :authorize

  helper :messages

  include MessagesHelper

  helper :sort

  include SortHelper

  helper :watchers

  include WatchersHelper

  def index

    @boards = @project.boards

    # show the board if there is only one

    if @boards.size == 1

      @board = @boards.first

      show

    end

  end

  def show

    sort_init "#{Message.table_name}.updated_on", "desc"

    sort_update	

    @topic_count = @board.topics.count

    @topic_pages = Paginator.new self, @topic_count, per_page_option, params['page']

    @topics =  @board.topics.find :all, :order => "#{Message.table_name}.sticky DESC, #{sort_clause}",

                                  :include => [:author, {:last_reply => :author}],

                                  :limit  =>  @topic_pages.items_per_page,

                                  :offset =>  @topic_pages.current.offset

    render :action => 'show', :layout => !request.xhr?

  end

  verify :method => :post, :only => [ :destroy ], :redirect_to => { :action => :index }

  def new

    @board = Board.new(params[:board])

    @board.project = @project

    if request.post? && @board.save

      flash[:notice] = l(:notice_successful_create)

      redirect_to :controller => 'projects', :action => 'settings', :id => @project, :tab => 'boards'

    end

  end

  def edit

    if request.post? && @board.update_attributes(params[:board])

      case params[:position]

      when 'highest'; @board.move_to_top

      when 'higher'; @board.move_higher

      when 'lower'; @board.move_lower

      when 'lowest'; @board.move_to_bottom

      end if params[:position]

      redirect_to :controller => 'projects', :action => 'settings', :id => @project, :tab => 'boards'

    end

  end

  def destroy

    @board.destroy

    redirect_to :controller => 'projects', :action => 'settings', :id => @project, :tab => 'boards'

  end

private

  def find_project

    @project = Project.find(params[:project_id])

    @board = @project.boards.find(params[:id]) if params[:id]

  rescue ActiveRecord::RecordNotFound

    render_404

  end

end

# redMine - project management software

# Copyright (C) 2006  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 CustomFieldsController < ApplicationController

  layout 'base'		

  before_filter :require_admin

  def index

    list

    render :action => 'list' unless request.xhr?

  end

  def list

    @custom_fields_by_type = CustomField.find(:all).group_by {|f| f.class.name }

    @tab = params[:tab] || 'IssueCustomField'

    render :action => "list", :layout => false if request.xhr?

  end

  def new

    case params[:type]

      when "IssueCustomField" 

        @custom_field = IssueCustomField.new(params[:custom_field])

        @custom_field.trackers = Tracker.find(params[:tracker_ids]) if params[:tracker_ids]

      when "UserCustomField" 

        @custom_field = UserCustomField.new(params[:custom_field])

      when "ProjectCustomField" 

        @custom_field = ProjectCustomField.new(params[:custom_field])

      else

        redirect_to :action => 'list'

        return

    end  

    if request.post? and @custom_field.save

      flash[:notice] = l(:notice_successful_create)

      redirect_to :action => 'list', :tab => @custom_field.class.name

    end

    @trackers = Tracker.find(:all, :order => 'position')

  end

  def edit

    @custom_field = CustomField.find(params[:id])

    if request.post? and @custom_field.update_attributes(params[:custom_field])

      if @custom_field.is_a? IssueCustomField

        @custom_field.trackers = params[:tracker_ids] ? Tracker.find(params[:tracker_ids]) : []

      end

      flash[:notice] = l(:notice_successful_update)

      redirect_to :action => 'list', :tab => @custom_field.class.name

    end

    @trackers = Tracker.find(:all, :order => 'position')

  end

  def move

    @custom_field = CustomField.find(params[:id])

    case params[:position]

    when 'highest'

      @custom_field.move_to_top

    when 'higher'

      @custom_field.move_higher

    when 'lower'

      @custom_field.move_lower

    when 'lowest'

      @custom_field.move_to_bottom

    end if params[:position]

    redirect_to :action => 'list', :tab => @custom_field.class.name

  end

  def destroy

    @custom_field = CustomField.find(params[:id]).destroy

    redirect_to :action => 'list', :tab => @custom_field.class.name

  rescue

    flash[:error] = "Unable to delete custom field"

    redirect_to :action => 'list'

  end

end

# redMine - project management software

# Copyright (C) 2006-2007  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class DocumentsController < ApplicationController

  layout 'base'

  before_filter :find_project, :only => [:index, :new]

  before_filter :find_document, :except => [:index, :new]

  before_filter :authorize

  helper :attachments

  def index

    @sort_by = %w(category date title author).include?(params[:sort_by]) ? params[:sort_by] : 'category'

    documents = @project.documents.find :all, :include => [:attachments, :category]

    case @sort_by

    when 'date'

      @grouped = documents.group_by {|d| d.created_on.to_date }

    when 'title'

      @grouped = documents.group_by {|d| d.title.first.upcase}

    when 'author'

      @grouped = documents.select{|d| d.attachments.any?}.group_by {|d| d.attachments.last.author}

    else

      @grouped = documents.group_by(&:category)

    end

    render :layout => false if request.xhr?

  end

  def show

    @attachments = @document.attachments.find(:all, :order => "created_on DESC")

  end

  def new

    @document = @project.documents.build(params[:document])    

    if request.post? and @document.save	

      attach_files(@document, params[:attachments])

      flash[:notice] = l(:notice_successful_create)

      Mailer.deliver_document_added(@document) if Setting.notified_events.include?('document_added')

      redirect_to :action => 'index', :project_id => @project

    end

  end

  def edit

    @categories = Enumeration::get_values('DCAT')

    if request.post? and @document.update_attributes(params[:document])

      flash[:notice] = l(:notice_successful_update)

      redirect_to :action => 'show', :id => @document

    end

  end  

  def destroy

    @document.destroy

    redirect_to :controller => 'documents', :action => 'index', :project_id => @project

  end

  def download

    @attachment = @document.attachments.find(params[:attachment_id])

    @attachment.increment_download

    send_file @attachment.diskfile, :filename => filename_for_content_disposition(@attachment.filename),

                                    :type => @attachment.content_type

  rescue

    render_404

  end 

  def add_attachment

    attachments = attach_files(@document, params[:attachments])

    Mailer.deliver_attachments_added(attachments) if !attachments.empty? && Setting.notified_events.include?('document_added')

    redirect_to :action => 'show', :id => @document

  end

  def destroy_attachment

    @document.attachments.find(params[:attachment_id]).destroy

    redirect_to :action => 'show', :id => @document

  end

private

  def find_project

    @project = Project.find(params[:project_id])

  rescue ActiveRecord::RecordNotFound

    render_404

  end

  def find_document

    @document = Document.find(params[:id])

    @project = @document.project

  rescue ActiveRecord::RecordNotFound

    render_404

  end

end

# redMine - project management software

# Copyright (C) 2006  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class EnumerationsController < ApplicationController

  layout 'base'

  before_filter :require_admin

  def index

    list

    render :action => 'list'

  end

  # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)

  verify :method => :post, :only => [ :destroy, :create, :update ],

         :redirect_to => { :action => :list }

  def list

  end

  def new

    @enumeration = Enumeration.new(:opt => params[:opt])

  end

  def create

    @enumeration = Enumeration.new(params[:enumeration])

    if @enumeration.save

      flash[:notice] = l(:notice_successful_create)

      redirect_to :action => 'list', :opt => @enumeration.opt

    else

      render :action => 'new'

    end

  end

  def edit

    @enumeration = Enumeration.find(params[:id])

  end

  def update

    @enumeration = Enumeration.find(params[:id])

    if @enumeration.update_attributes(params[:enumeration])

      flash[:notice] = l(:notice_successful_update)

      redirect_to :action => 'list', :opt => @enumeration.opt

    else

      render :action => 'edit'

    end

  end

  def move

    @enumeration = Enumeration.find(params[:id])

    case params[:position]

    when 'highest'

      @enumeration.move_to_top

    when 'higher'

      @enumeration.move_higher

    when 'lower'

      @enumeration.move_lower

    when 'lowest'

      @enumeration.move_to_bottom

    end if params[:position]

    redirect_to :action => 'index'

  end

  def destroy

    Enumeration.find(params[:id]).destroy

    flash[:notice] = l(:notice_successful_delete)

    redirect_to :action => 'list'

  rescue

    flash[:error] = "Unable to delete enumeration"

    redirect_to :action => 'list'

  end

end

# redMine - project management software

# Copyright (C) 2006  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 IssueCategoriesController < ApplicationController

  layout 'base'

  menu_item :settings

  before_filter :find_project, :authorize

  verify :method => :post, :only => :destroy

  def edit

    if request.post? and @category.update_attributes(params[:category])

      flash[:notice] = l(:notice_successful_update)

      redirect_to :controller => 'projects', :action => 'settings', :tab => 'categories', :id => @project

    end

  end

  def destroy

    @issue_count = @category.issues.size

    if @issue_count == 0

      # No issue assigned to this category

      @category.destroy

      redirect_to :controller => 'projects', :action => 'settings', :id => @project, :tab => 'categories'

    elsif params[:todo]

      reassign_to = @project.issue_categories.find_by_id(params[:reassign_to_id]) if params[:todo] == 'reassign'

      @category.destroy(reassign_to)

      redirect_to :controller => 'projects', :action => 'settings', :id => @project, :tab => 'categories'

    end

    @categories = @project.issue_categories - [@category]

  end

private

  def find_project

    @category = IssueCategory.find(params[:id])

    @project = @category.project

  rescue ActiveRecord::RecordNotFound

    render_404

  end    

end

# redMine - project management software

# Copyright (C) 2006-2007  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class IssueRelationsController < ApplicationController

  layout 'base'

  before_filter :find_project, :authorize

  def new

    @relation = IssueRelation.new(params[:relation])

    @relation.issue_from = @issue

    @relation.save if request.post?

    respond_to do |format|

      format.html { redirect_to :controller => 'issues', :action => 'show', :id => @issue }

      format.js do

        render :update do |page|

          page.replace_html "relations", :partial => 'issues/relations'

          if @relation.errors.empty?

            page << "$('relation_delay').value = ''"

            page << "$('relation_issue_to_id').value = ''"

          end

        end

      end

    end

  end

  def destroy

    relation = IssueRelation.find(params[:id])

    if request.post? && @issue.relations.include?(relation)

      relation.destroy

      @issue.reload

    end

    respond_to do |format|

      format.html { redirect_to :controller => 'issues', :action => 'show', :id => @issue }

      format.js { render(:update) {|page| page.replace_html "relations", :partial => 'issues/relations'} }

    end

  end

private

  def find_project

    @issue = Issue.find(params[:issue_id])

    @project = @issue.project

  rescue ActiveRecord::RecordNotFound

    render_404

  end

end

# redMine - project management software

# Copyright (C) 2006  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 IssueStatusesController < ApplicationController

  layout 'base'	

  before_filter :require_admin

  verify :method => :post, :only => [ :destroy, :create, :update, :move ],

         :redirect_to => { :action => :list }

  def index

    list

    render :action => 'list' unless request.xhr?

  end

  def list

    @issue_status_pages, @issue_statuses = paginate :issue_statuses, :per_page => 25, :order => "position"

    render :action => "list", :layout => false if request.xhr?

  end

  def new

    @issue_status = IssueStatus.new

  end

  def create

    @issue_status = IssueStatus.new(params[:issue_status])

    if @issue_status.save

      flash[:notice] = l(:notice_successful_create)

      redirect_to :action => 'list'

    else

      render :action => 'new'

    end

  end

  def edit

    @issue_status = IssueStatus.find(params[:id])

  end

  def update

    @issue_status = IssueStatus.find(params[:id])

    if @issue_status.update_attributes(params[:issue_status])

      flash[:notice] = l(:notice_successful_update)

      redirect_to :action => 'list'

    else

      render :action => 'edit'

    end

  end

  def move

    @issue_status = IssueStatus.find(params[:id])

    case params[:position]

    when 'highest'

      @issue_status.move_to_top

    when 'higher'

      @issue_status.move_higher

    when 'lower'

      @issue_status.move_lower

    when 'lowest'

      @issue_status.move_to_bottom

    end if params[:position]

    redirect_to :action => 'list'

  end

  def destroy

    IssueStatus.find(params[:id]).destroy

    redirect_to :action => 'list'

  rescue

    flash[:error] = "Unable to delete issue status"

    redirect_to :action => 'list'

  end  	

end

# redMine - project management software

# Copyright (C) 2006-2007  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class IssuesController < ApplicationController

  layout 'base'

  menu_item :new_issue, :only => :new

  before_filter :find_issue, :only => [:show, :edit, :destroy_attachment]

  before_filter :find_issues, :only => [:bulk_edit, :move, :destroy]

  before_filter :find_project, :only => [:new, :update_form, :preview]

  before_filter :authorize, :except => [:index, :changes, :preview, :update_form, :context_menu]

  before_filter :find_optional_project, :only => [:index, :changes]

  accept_key_auth :index, :changes

  helper :journals

  helper :projects

  include ProjectsHelper   

  helper :custom_fields

  include CustomFieldsHelper

  helper :ifpdf

  include IfpdfHelper

  helper :issue_relations

  include IssueRelationsHelper

  helper :watchers

  include WatchersHelper

  helper :attachments

  include AttachmentsHelper

  helper :queries

  helper :sort

  include SortHelper

  include IssuesHelper

  def index

    sort_init "#{Issue.table_name}.id", "desc"

    sort_update

    retrieve_query

    if @query.valid?

      limit = per_page_option

      respond_to do |format|

        format.html { }

        format.atom { }

        format.csv  { limit = Setting.issues_export_limit.to_i }

        format.pdf  { limit = Setting.issues_export_limit.to_i }

      end

      @issue_count = Issue.count(:include => [:status, :project], :conditions => @query.statement)

      @issue_pages = Paginator.new self, @issue_count, limit, params['page']

      @issues = Issue.find :all, :order => sort_clause,

                           :include => [ :assigned_to, :status, :tracker, :project, :priority, :category, :fixed_version ],

                           :conditions => @query.statement,

                           :limit  =>  limit,

                           :offset =>  @issue_pages.current.offset

      respond_to do |format|

        format.html { render :template => 'issues/index.rhtml', :layout => !request.xhr? }

        format.atom { render_feed(@issues, :title => l(:label_issue_plural)) }

        format.csv  { send_data(issues_to_csv(@issues, @project).read, :type => 'text/csv; header=present', :filename => 'export.csv') }

        format.pdf  { send_data(render(:template => 'issues/index.rfpdf', :layout => false), :type => 'application/pdf', :filename => 'export.pdf') }

      end

    else

      # Send html if the query is not valid

      render(:template => 'issues/index.rhtml', :layout => !request.xhr?)

    end

  end

  def changes

    sort_init "#{Issue.table_name}.id", "desc"

    sort_update

    retrieve_query

    if @query.valid?

      @journals = Journal.find :all, :include => [ :details, :user, {:issue => [:project, :author, :tracker, :status]} ],

                                     :conditions => @query.statement,

                                     :limit => 25,

                                     :order => "#{Journal.table_name}.created_on DESC"

    end

    @title = (@project ? @project.name : Setting.app_title) + ": " + (@query.new_record? ? l(:label_changes_details) : @query.name)

    render :layout => false, :content_type => 'application/atom+xml'

  end

  def show

    @custom_values = @project.custom_fields_for_issues(@issue.tracker).collect { |x| @issue.custom_values.find_by_custom_field_id(x.id) || CustomValue.new(:custom_field => x, :customized => @issue) }

    @journals = @issue.journals.find(:all, :include => [:user, :details], :order => "#{Journal.table_name}.created_on ASC")

    @journals.each_with_index {|j,i| j.indice = i+1}

    @journals.reverse! if User.current.wants_comments_in_reverse_order?

    @allowed_statuses = @issue.new_statuses_allowed_to(User.current)

    @edit_allowed = User.current.allowed_to?(:edit_issues, @project)

    @activities = Enumeration::get_values('ACTI')

    @priorities = Enumeration::get_values('IPRI')

    respond_to do |format|

      format.html { render :template => 'issues/show.rhtml' }

      format.atom { render :action => 'changes', :layout => false, :content_type => 'application/atom+xml' }

      format.pdf  { send_data(render(:template => 'issues/show.rfpdf', :layout => false), :type => 'application/pdf', :filename => "#{@project.identifier}-#{@issue.id}.pdf") }

    end

  end

  # Add a new issue

  # The new issue will be created from an existing one if copy_from parameter is given

  def new

    @issue = params[:copy_from] ? Issue.new.copy_from(params[:copy_from]) : Issue.new(params[:issue])

    @issue.project = @project

    @issue.author = User.current

    @issue.tracker ||= @project.trackers.find(params[:tracker_id] ? params[:tracker_id] : :first)

    if @issue.tracker.nil?

      flash.now[:error] = 'No tracker is associated to this project. Please check the Project settings.'

      render :nothing => true, :layout => true

      return

    end

    default_status = IssueStatus.default

    unless default_status

      flash.now[:error] = 'No default issue status is defined. Please check your configuration (Go to "Administration -> Issue statuses").'

      render :nothing => true, :layout => true

      return

    end    

    @issue.status = default_status

    @allowed_statuses = ([default_status] + default_status.find_new_statuses_allowed_to(User.current.role_for_project(@project), @issue.tracker)).uniq

    if request.get? || request.xhr?

      @issue.start_date ||= Date.today

      @custom_values = @issue.custom_values.empty? ?

        @project.custom_fields_for_issues(@issue.tracker).collect { |x| CustomValue.new(:custom_field => x, :customized => @issue) } :

        @issue.custom_values

    else

      requested_status = IssueStatus.find_by_id(params[:issue][:status_id])

      # Check that the user is allowed to apply the requested status

      @issue.status = (@allowed_statuses.include? requested_status) ? requested_status : default_status

      @custom_values = @project.custom_fields_for_issues(@issue.tracker).collect { |x| CustomValue.new(:custom_field => x, :customized => @issue, :value => params["custom_fields"][x.id.to_s]) }

      @issue.custom_values = @custom_values

      if @issue.save

        attach_files(@issue, params[:attachments])