Redmine

  end

  def edit

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

      flash[:notice] = l(:notice_successful_update)

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

  end

  def new

  end

  def create

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

    if @enumeration.save

      flash[:notice] = l(:notice_successful_create)

    else

      render :action => 'new'

    end

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

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

      flash[:notice] = l(:notice_successful_update)

    else

      render :action => 'edit'

    end

      @enumeration.destroy

      redirect_to :action => 'index'

    elsif params[:reassign_to_id]

        @enumeration.destroy(reassign_to)

        redirect_to :action => 'index'

      end

    end

  #rescue

  #  flash[:error] = 'Unable to delete enumeration'

  #  redirect_to :action => 'index'

    @changesets.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)

    @time_entry = TimeEntry.new

    respond_to do |format|

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

        return

      end		

    end	

    render :layout => !request.xhr?

  end

  def edit

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

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

    @time_entry = TimeEntry.new

  def bulk_edit

    if request.post?

      status = params[:status_id].blank? ? nil : IssueStatus.find_by_id(params[:status_id])

      assigned_to = (params[:assigned_to_id].blank? || params[:assigned_to_id] == 'none') ? nil : User.find_by_id(params[:assigned_to_id])

      category = (params[:category_id].blank? || params[:category_id] == 'none') ? nil : @project.issue_categories.find_by_id(params[:category_id])

      fixed_version = (params[:fixed_version_id].blank? || params[:fixed_version_id] == 'none') ? nil : @project.versions.find_by_id(params[:fixed_version_id])

      @assignables << @issue.assigned_to if @issue && @issue.assigned_to && !@assignables.include?(@issue.assigned_to)

    end

    @statuses = IssueStatus.find(:all, :order => 'position')

    @back = request.env['HTTP_REFERER']

      render :template => "reports/issue_report_details"

    when "priority"

      @field = "priority_id"

      @data = issues_by_priority

      @report_title = l(:field_priority)

      render :template => "reports/issue_report_details"   

    else

      @trackers = @project.trackers

      @versions = @project.versions.sort

      @categories = @project.issue_categories

      @assignees = @project.members.collect { |m| m.user }

      @authors = @project.members.collect { |m| m.user }

                                                  p.id as priority_id,

                                                  count(i.id) as total 

                                                from 

                                                where 

                                                  i.status_id=s.id 

                                                  and i.priority_id=p.id

                                          :klass => Tracker,

                                          :label => :label_tracker},

                             'activity' => {:sql => "#{TimeEntry.table_name}.activity_id",

                                           :label => :label_activity},

                             'issue' => {:sql => "#{TimeEntry.table_name}.issue_id",

                                         :klass => Issue,

        u = User.find_by_id(detail.value) and value = u.name if detail.value

        u = User.find_by_id(detail.old_value) and old_value = u.name if detail.old_value

      when 'priority_id'

      when 'category_id'

        c = IssueCategory.find_by_id(detail.value) and value = c.name if detail.value

        c = IssueCategory.find_by_id(detail.old_value) and old_value = c.name if detail.old_value

  end

  def activity_collection_for_select_options

    collection = []

    collection << [ "--- #{l(:actionview_instancetag_blank_option)} ---", '' ] unless activities.detect(&:is_default)

    activities.each { |a| collection << [a.name, a.id] }

class Document < ActiveRecord::Base

  belongs_to :project

  acts_as_attachable :delete_permission => :manage_documents

  acts_as_searchable :columns => ['title', "#{table_name}.description"], :include => :project

  def after_initialize

    if new_record?

    end

  end

end

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

class Enumeration < ActiveRecord::Base

  before_destroy :check_integrity

  validates_length_of :name, :maximum => 30

    end

  end

    def default

      find(:first, :conditions => { :is_default => true })

    end

  end

  def option_name

  end

  def before_save

    if is_default? && is_default_changed?

    end

  end

  def objects_count

  end

  def in_use?

  # If a enumeration is specified, objects are reassigned

  def destroy(reassign_to = nil)

    if reassign_to && reassign_to.is_a?(Enumeration)

    end

    destroy_without_reassign

  end

  end

  def to_s; name end

private

  def check_integrity

    raise "Can't delete enumeration" if self.in_use?

  end

end

  belongs_to :author, :class_name => 'User', :foreign_key => 'author_id'

  belongs_to :assigned_to, :class_name => 'User', :foreign_key => 'assigned_to_id'

  belongs_to :fixed_version, :class_name => 'Version', :foreign_key => 'fixed_version_id'

  belongs_to :category, :class_name => 'IssueCategory', :foreign_key => 'category_id'

  has_many :journals, :as => :journalized, :dependent => :destroy

    if new_record?

      # set default values for new records only

      self.status ||= IssueStatus.default

    end

  end

    project = target_project

    tracker = (get_keyword(:tracker) && project.trackers.find_by_name(get_keyword(:tracker))) || project.trackers.find(:first)

    category = (get_keyword(:category) && project.issue_categories.find_by_name(get_keyword(:category)))

    status =  (get_keyword(:status) && IssueStatus.find_by_name(get_keyword(:status)))

    # check permission

    QueryColumn.new(:project, :sortable => "#{Project.table_name}.name"),

    QueryColumn.new(:tracker, :sortable => "#{Tracker.table_name}.position"),

    QueryColumn.new(:status, :sortable => "#{IssueStatus.table_name}.position"),

    QueryColumn.new(:subject, :sortable => "#{Issue.table_name}.subject"),

    QueryColumn.new(:author),

    QueryColumn.new(:assigned_to, :sortable => ["#{User.table_name}.lastname", "#{User.table_name}.firstname"]),

    @available_filters = { "status_id" => { :type => :list_status, :order => 1, :values => IssueStatus.find(:all, :order => 'position').collect{|s| [s.name, s.id.to_s] } },       

                           "tracker_id" => { :type => :list, :order => 2, :values => trackers.collect{|s| [s.name, s.id.to_s] } },                                                                                                                

                           "subject" => { :type => :text, :order => 8 },  

                           "created_on" => { :type => :date_past, :order => 9 },                        

                           "updated_on" => { :type => :date_past, :order => 10 },

  belongs_to :project

  belongs_to :issue

  belongs_to :user

  attr_protected :project_id, :user_id, :tyear, :tmonth, :tweek

  def after_initialize

    if new_record? && self.activity.nil?

        self.activity_id = default_activity.id

      end

    end

<div class="box">

<!--[form:document]-->

<p><label for="document_category_id"><%=l(:field_category)%></label>

<p><label for="document_title"><%=l(:field_title)%> <span class="required">*</span></label>

<%= text_field 'document', 'title', :size => 60 %></p>

<h2><%=l(:label_enumerations)%></h2>

<% if enumerations.any? %>

<table class="list">

<% enumerations.each do |enumeration| %>

<% reset_cycle %>

<% end %>

<% end %>

<% html_title(l(:label_enumerations)) -%>

<%= select_tag('status_id', "<option value=\"\">#{l(:label_no_change_option)}</option>" + options_from_collection_for_select(@available_statuses, :id, :name)) %></label>

<% end %>

<label><%= l(:field_priority) %>: 

<label><%= l(:field_category) %>: 

<%= select_tag('category_id', content_tag('option', l(:label_no_change_option), :value => '') +

                                content_tag('option', l(:label_none), :value => 'none') +

                                :conditions => {:assigned_to_id => User.current.id},

                                :limit => 10, 

                                :include => [ :status, :project, :tracker, :priority ], 

<%= render :partial => 'issues/list_simple', :locals => { :issues => assigned_issues } %>

<% if assigned_issues.length > 0 %>

<p class="small"><%= link_to l(:label_issue_view_all), :controller => 'issues',

      def url; 'http://www.redmine.org/' end

      def help_url; 'http://www.redmine.org/guide' end

      def versioned_name; "#{app_name} #{Redmine::VERSION}" end

    end

  end

end

  name: Uncategorized

  id: 1

  opt: DCAT

enumerations_002: 

  name: User documentation

  id: 2

  opt: DCAT

enumerations_003: 

  name: Technical documentation

  id: 3

  opt: DCAT

enumerations_004: 

  name: Low

  id: 4

  opt: IPRI

enumerations_005: 

  name: Normal

  id: 5

  opt: IPRI

  is_default: true

enumerations_006: 

  name: High

  id: 6

  opt: IPRI

enumerations_007: 

  name: Urgent

  id: 7

  opt: IPRI

enumerations_008: 

  name: Immediate

  id: 8

  opt: IPRI

enumerations_009: 

  name: Design

  id: 9

  opt: ACTI

enumerations_010: 

  name: Development

  id: 10

  opt: ACTI

  is_default: true

enumerations_011: 

  name: QA

  id: 11

  opt: ACTI

  created_on: <%= 10.days.ago.to_date.to_s(:db) %>

  project_id: 1

  updated_on: <%= 10.days.ago.to_date.to_s(:db) %>

  subject: Issue due today

  id: 7

  fixed_version_id: 

  created_on: <%= 10.days.ago.to_date.to_s(:db) %>

  project_id: 1

  updated_on: <%= 10.days.ago.to_date.to_s(:db) %>

  subject: Closed issue

  id: 8

  fixed_version_id: 

           :id => 1,

           :issue => { :status_id => 2, :assigned_to_id => 3 },

           :notes => 'Assigned to dlopper',

    end

    assert_redirected_to :action => 'show', :id => '1'

    issue.reload

      post :edit,

           :id => 1,

           :notes => '2.5 hours added',

    end

    assert_redirected_to :action => 'show', :id => '1'

    post 'projects/1/issues', :tracker_id => "1",

                                 :issue => { :start_date => "2006-12-26", 

                                             :subject => "new test issue", 

                                             :category_id => "", 

                                             :description => "new issue", 

  end

  def test_default

    assert e.is_a?(Enumeration)

    assert e.is_default?

    assert_equal 'Normal', e.name

  end

  def test_create

    assert e.save

  end

  def test_create_as_default

    assert e.save

  end

  def test_update_default

    e.update_attributes(:name => 'Changed', :is_default => true)

  end

  def test_update_default_to_non_default

    e.update_attributes(:name => 'Changed', :is_default => false)

  end

  def test_change_default

    e.update_attributes(:name => 'Urgent', :is_default => true)

  end

  def test_destroy_with_reassign

           :time_entries

  def test_create

    assert issue.save

    issue.reload

    assert_equal 1.5, issue.estimated_hours

  end

  def test_create_minimal

    assert issue.save

    assert issue.description.nil?

  end

  end

  def test_category_based_assignment

    assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to

  end

  def test_should_close_duplicates

    # Create 3 issues

    assert issue1.save

    issue2 = issue1.clone

    assert issue2.save

  def test_should_not_close_duplicated_issue

    # Create 3 issues

    assert issue1.save

    issue2 = issue1.clone

    assert issue2.save