Redmine

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

  before_filter :find_parent_issue, :only => [:add_subissue]

  before_filter :find_optional_parent_issue, :only => [:new]

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

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

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

  include ActionView::Helpers::PrototypeHelper

  def auto_complete_for_issue_parent

    @phrase = params[:issue_parent]

    @candidates = []

    # If cross project issue relations is allowed we should get

    # candidates from every project

    if Setting.cross_project_issue_relations?

      projects_to_search = nil

    else

      projects_to_search = [ @project ] + @project.active_children

    end

    # Try to find issue by id.

    if @phrase.match(/^#?(\d+)$/)

      if Setting.cross_project_issue_relations?

        issue = Issue.find_by_id( $1)

      else

        issue = Issue.find_by_id_and_project_id( $1, projects_to_search.collect { |i| i.id})

      end

      @candidates = [ issue ] if issue

    end

    # If finding by id is fail, try to find by searching in subject

    # and description.

    if @candidates.empty?

      # extract tokens from the question

      # eg. hello "bye bye" => ["hello", "bye bye"]

      tokens = @phrase.scan(%r{((\s|^)"[\s\w]+"(\s|$)|\S+)}).collect {|m| m.first.gsub(%r{(^\s*"\s*|\s*"\s*$)}, '')}

      # tokens must be at least 3 character long

      tokens = tokens.uniq.select {|w| w.length > 2 }

      like_tokens = tokens.collect {|w| "%#{w.downcase}%"}      

      @candidates, count = Issue.search( like_tokens, projects_to_search, :before => true)

    end

    render :inline => "<%= auto_complete_result_parent_issue( @candidates, @phrase) %>"

  end

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

        @issue.move_to_child_of @parent_issue if @parent_issue

  def add_subissue

    redirect_to :action => 'new', :issue => { :parent_issue_id => @parent_issue.id }

  end

  def find_parent_issue

    @parent_issue = Issue.find( params[:parent_issue_id])

  rescue ActiveRecord::RecordNotFound

    render_404

  end

  def find_optional_parent_issue

    if params[:issue] && !params[:issue][:parent_id].blank?

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

    end

  rescue ActiveRecord::RecordNotFound

    render_404

  end

        if params[:view_options] and params[:view_options].is_a? Hash

          params[:view_options].each_pair do |name, value|

            @query.set_view_option( name, value)

          end

        end

        session[:query] = {

          :project_id => @query.project_id,

          :filters => @query.filters,

          :view_options => @query.view_options

        }

        @query ||= Query.new(:name => "_",

                             :project => @project,

                             :filters => session[:query][:filters],

                             :view_options => session[:query][:view_options])

  helper :versions

  include VersionsHelper

  def sort_as_tree(issues)

    issues.sort!{|a,b| a.hierarchical_level <=> b.hierarchical_level}

    @sorted_issues = []

    issues.each do |issue|

      if @sorted_issues.empty?

        @sorted_issues << issue

        next

      end

      @time_to_stop = false #indicates when this task reaches its parent task (important because it has to stop between its parent task and the next aunt task

      @sorted_issues.each do |sorted_issue|

        #if same parent and smaller date, stop; if same parent, same date and smaller id, stop; after parent and before next parent, stop; 

        if ((sorted_issue.parent == issue.parent) && (sorted_issue.start_date > issue.start_date)) ||

         ((sorted_issue.parent == issue.parent) && (sorted_issue.start_date == issue.start_date) && (sorted_issue.id > issue.id)) ||

         (@time_to_stop && (sorted_issue.hierarchical_level < issue.hierarchical_level))

          @sorted_issues.insert(@sorted_issues.index(sorted_issue), issue)

          break

        end

        @time_to_stop = true if sorted_issue == issue.parent      

      end

      #if this issue's parent is the last element

      @sorted_issues << issue if @time_to_stop

    end

    @sorted_issues

  end

  #assumes that first level issues are ordered by date (sort_as_tree)

  def integrate_versions_with_issues_tree(issues, versions)

    versions.sort! {|x,y| x.start_date <=> y.start_date }    

    versions.each do |version|

      issues << version if issues.empty?

      issues.each do |issue|

        if ((issue.is_a? Issue && issue.root?) || (issue.is_a? Version)) && version.start_date < issue.start_date

          #insert version before a root task or another version whose date is immediately after this task's one 

          issues.insert(issues.index(issue), version)

        elsif issue == issues.last

          issues << version        

        end

      end

    end

    issues

  end  

    params[:view_options].each_pair do |name, value|

      @query.set_view_option( name, value)

    end if params[:view_options]

      params[:view_options].each_pair do |name, value|

        @query.set_view_option( name, value)

      end if params[:view_options]

    @issues = @version.fixed_issues.find(:all,

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

                                         :order => "#{Tracker.table_name}.position, #{Issue.table_name}.id")

    @issues = Issue.find_with_parents( @issues.collect { |i| i.id})

  def issue_ancestors(issue=@issue)

    ancestors = ""

    return "" if issue.parent == nil

    ancestors += "issue-#{issue.parent.id}-child " + issue_ancestors(issue.parent)        

  end

  def auto_complete_result_parent_issue(candidates, phrase)

    return "" if candidates.empty?

    candidates.map! do |c|

      content_tag("li", highlight( c.to_s, phrase), :id => String( c[:id]))

    end

    content_tag("ul", candidates.uniq)

  end

# -*- coding: mule-utf-8 -*-

  def column_content(column, issue, query)

          subject_in_tree(issue, value, query)

  def subject_in_tree(issue, value, query)

    case query.view_options['show_parents']

    when Query::VIEW_OPTIONS_SHOW_PARENTS_NEVER

      content_tag('div', subject_text(issue, value), :class=>'issue-subject')

    else

      content_tag('span', content_tag('div', subject_text(issue, value), :class=>'issue-subject'), :class=>"issue-subject-level-#{issue.hierarchical_level}")

    end

  end

  def subject_text(issue, value)

    subject_text = link_to(h(value), :controller => 'issues', :action => 'show', :id => issue)

    h((@project.nil? || @project != issue.project) ? "#{issue.project.name} - " : '') + subject_text

  end

  def issue_content(issue, query, options = { })

    html = ""

    html << "<tr id=\"issue-#{issue.id}\" class=\"issue hascontextmenu " +

      ( options[:unfiltered] ? 'issue-unfiltered ' : '') +

      "status-#{issue.status.position} priority-#{issue.priority.position} " +

      cycle('odd', 'even') + '">'

    html << '<td class="checkbox">' + check_box_tag( "ids[]", issue.id, false, :id => nil) + '</td>'

    html << '<td>' + link_to( issue.id, :controller => 'issues', :action => 'show', :id => issue) + '</td>'

    query.columns.each do |column|

      html << content_tag( 'td', column_content(column, issue, query), :class => column.name)

    end

    html << "</tr>"

    html

  end

  def issues_family_content( parent, issues_to_show, query)

    html = ""

    html << issue_content( parent, query, :unfiltered => !( issues_to_show.include? parent))

    unless  parent.children.empty?

      parent.children.each do |child|

        if issues_to_show.include?( child) || issues_to_show.detect { |i| i.ancestors.include? child }

          html << issues_family_content( child, issues_to_show, query)

        end

      end

    end

    html

  end

  def render_list_of_related_issues( issues, version, current_level = 1)

    issues_on_current_level = issues.select { |i| i.hierarchical_level == current_level }

    issues -= issues_on_current_level

    content_tag( 'ul') do

      html = ''

      issues_on_current_level.each do |issue|

        opts_for_issue_li = { }

        if !issue.fixed_version or issue.fixed_version != version

          opts_for_issue_li[:class] = 'issue-unfiltered'

        end

        html << content_tag( 'li', opts_for_issue_li) do

          opts = { }

          if issue.done_ratio == 100

            opts[:style] = 'font-weight: bold'

          end

          link_to_issue(issue, opts)  + ": " + h(issue.subject)

        end

        children_to_print = issues & issue.children

        children_to_print += issues.select { |i| i.hierarchical_level >= current_level + 2}

        unless children_to_print.empty?

          html << render_list_of_related_issues( children_to_print, version, current_level + 1)

        end

      end

      html

    end

  end

  belongs_to :status,        :class_name => 'IssueStatus',   :foreign_key => 'status_id'

  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 :priority,      :class_name => 'Enumeration',   :foreign_key => 'priority_id'

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

  has_many :relations_to,   :class_name => 'IssueRelation', :foreign_key => 'issue_to_id',   :dependent => :delete_all

  acts_as_nested_set

  alias_method :nested_set_move_to, :move_to

  # Move the node to the left of another node (you can pass id only)

  def move_to_left_of(node)

    nested_set_move_to node, :left

  end

  # Move the node to the left of another node (you can pass id only)

  def move_to_right_of(node)

    nested_set_move_to node, :right

  end

  # Move the node to the child of another node (you can pass id only)

  def move_to_child_of(node)

    nested_set_move_to node, :child

  end

  # Move the node to root nodes

  def move_to_root

    nested_set_move_to nil, :root

  end

    # FIXME: I do not know what actually this should do, but this

    # validation does not allow me to change due_date in hook when

    # fixed_version is set.

    unless children.empty?

      if IssueStatus.find_by_id( @attributes['status_id']).is_closed? &&

          children.detect { |i| !i.closed? }

        errors.add( :status,

                    "Can't close parent issue " +

                    "while one of the children is still open.")

      end

      children_max_fixed_version = children.select { |i| i.fixed_version } .max { |a,b| a.fixed_version <=> b.fixed_version }

      if @attributes['fixed_version_id'] && children_max_fixed_version

        if Version.find_by_id( @attributes['fixed_version_id']) < children_max_fixed_version.fixed_version

          errors.add :fixed_version, "Can't set target version of parent issue lower than any of the children."

        end

      end

    end

                                                      :value => send(c)) unless send(c)==@issue_before_change.send(c) || (!self.leaf? && %w(status_id priority_id fixed_version_id start_date due_date done_ratio estimated_hours).include?(c))

    if parent

      # Set default status of parent if new status opened the issue.

      if !status.is_closed? && parent.status.is_closed?

        parent.update_attribute :status, IssueStatus.default

      end

      # Set 'Target version' of parent if one was set on one of the

      # children issue and parent have no 'Target version'. Do the same

      # if 'Target version of the parent issue lower (by the release

      # date or by the version number).

      if parent.fixed_version.nil? && fixed_version or

          ( parent.fixed_version && fixed_version and

            parent.fixed_version.project == fixed_version.project and

            parent.fixed_version < fixed_version )

        parent.update_attribute :fixed_version, fixed_version

      end

    end

    # If target version is set, but "Due to" date is not, set it as

    # the same as the date of target version.

    if due_date.nil? && fixed_version && fixed_version.due_date

      self.update_attribute :due_date, fixed_version.due_date

    end

  # Returns true if usr or current user is allowed to view the issue

  def visible?(usr=nil)

    (usr || User.current).allowed_to?(:view_issues, self.project)

  end

  def after_initialize

    if new_record?

      # set default values for new records only

      self.status ||= IssueStatus.default

      self.priority ||= Enumeration.priorities.default

    end

  end

  # Overrides Redmine::Acts::Customizable::InstanceMethods#available_custom_fields

  def available_custom_fields

    (project && tracker) ? project.all_issue_custom_fields.select {|c| tracker.custom_fields.include? c } : []

  end

  def copy_from(arg)

    issue = arg.is_a?(Issue) ? arg : Issue.find(arg)

    self.attributes = issue.attributes.dup

    self.custom_values = issue.custom_values.collect {|v| v.clone}

    self

  end

  # Moves/copies an issue to a new project and tracker

  # Returns the moved/copied issue on success, false on failure

  def move_to(new_project, new_tracker = nil, options = {})

    options ||= {}

    issue = if options[:copy]

              Issue.new( self.attributes.reject { |k,v| k == 'parent_id' })

            else

              self

            end

    transaction do

      if new_project && issue.project_id != new_project.id

        unless Setting.cross_project_issue_relations?

          # delete issue relations

          issue.relations_from.clear

          issue.relations_to.clear

          issue.children.each(&:move_to_root) unless options[:copy]

        end

        # issue is moved to another project

        # reassign to the category with same name if any

        new_category = issue.category.nil? ? nil : new_project.issue_categories.find_by_name(issue.category.name)

        issue.category = new_category

        issue.fixed_version = nil

        issue.project = new_project

      end

      if new_tracker

        issue.tracker = new_tracker

      end

      if options[:copy]

        issue.custom_field_values = self.custom_field_values.inject({}) {|h,v| h[v.custom_field_id] = v.value; h}

        issue.status = self.status

      end

      if issue.save

        unless options[:copy]

          # Manually update project_id on related time entries

          TimeEntry.update_all("project_id = #{new_project.id}", {:issue_id => id})

        end

        if new_project && issue.project_id != new_project.id &&

            !Setting.cross_project_issue_relations?

          issue.move_to_root

        end

      else

        Issue.connection.rollback_db_transaction

        return false

      end

    end

    return issue

  end

  def estimated_hours=(h)

    write_attribute :estimated_hours, (h.is_a?(String) ? h.to_hours : h)

  end

  def priority_id=(pid)

    self.priority = nil

    write_attribute(:priority_id, pid)

  end

  def duration1

    (start_date && due_date) ? (due_date - start_date + 1) : 0

  end

  def self.visible_by(usr)

    with_scope(:find => { :conditions => Project.visible_by(usr) }) do

      yield

    end

  end

  def done_ratio

    if children?

      @total_planned_days ||= 0

      @total_actual_days ||= 0

      children.each do |child| # from every subtask get the total number of days and the number of days already "worked"

        planned_days = child.duration1

        actual_days = child.done_ratio ?  (planned_days * child.done_ratio / 100).floor : 0

        @total_planned_days += planned_days

        @total_actual_days += actual_days

      end

      @total_done_ratio = @total_planned_days != 0 ? (@total_actual_days * 100 / @total_planned_days).floor : 0

    else

      read_attribute(:done_ratio)

    end

  end

  def estimated_hours

    if children?

      is_set = false

      children.each do |child|

        if child.estimated_hours

          if is_set

            @est_hours += child.estimated_hours

          else

            @est_hours = child.estimated_hours

            is_set = true

          end

        end     

      end

      @est_hours

    else

      read_attribute(:estimated_hours)

    end

  end

  def due_date

    if children?

      children_date = children.find_all { |i| i.due_date } 

      unless children_date.empty?

        children_date.sort { |a,b| a.due_date <=> b.due_date} .max

      else

        read_attribute(:due_date)

      end

    else

      read_attribute(:due_date)

    end

  end  

  def children?

    children != []

  end

  #First level tasks have hierarchical level = 1 and so on

  def hierarchical_level(issue=self)

    1 + level

  end

  # FIXME: remove this method.

  def self.find_with_parents( *args)

    issues = find( *args)

    return [] if issues.empty?

    issues.each do |i|

      while not i.root?

        issues += [ i.parent ]

        i = i.parent

      end

    end

    issues.uniq

  end

  belongs_to :issue_to,   :class_name => 'Issue', :foreign_key => 'issue_to_id'

  TYPES = { TYPE_RELATES    => { :name => :label_relates_to, :sym_name => :label_relates_to,    :order => 1 },

            TYPE_DUPLICATES => { :name => :label_duplicates, :sym_name => :label_duplicated_by, :order => 2 },

            TYPE_BLOCKS     => { :name => :label_blocks,     :sym_name => :label_blocked_by,    :order => 3 },

            TYPE_PRECEDES   => { :name => :label_precedes,   :sym_name => :label_follows,       :order => 4 },

  validates_presence_of     :issue_from,    :issue_to, :relation_type 

  validates_inclusion_of    :relation_type, :in        => TYPES.keys

  validates_numericality_of :delay,         :allow_nil => true

  validates_uniqueness_of   :issue_to_id,   :scope     => :issue_from_id

class ViewOption

  attr_accessor :name, :available_values

  include Redmine::I18n

  def initialize( name, available_values)

    self.name = name

    self.available_values = available_values

  end

  def caption

    l("label_view_option_#{name}")

  end

end

  serialize :view_options

  VIEW_OPTIONS_SHOW_PARENTS_NEVER              = 'do_not_show'

  VIEW_OPTIONS_SHOW_PARENTS_ALWAYS             = 'show_always'

  VIEW_OPTIONS_SHOW_PARENTS_ORGANIZE_BY_PARENT = 'organize_by_parent'

  @@available_view_options = [

    ViewOption.new( 'show_parents', [ [ l(:label_view_option_parents_do_not_show), VIEW_OPTIONS_SHOW_PARENTS_NEVER ],

                                      [ l(:label_view_option_parents_show_always), VIEW_OPTIONS_SHOW_PARENTS_ALWAYS ],

                                      [ l(:label_view_option_parents_show_and_group), VIEW_OPTIONS_SHOW_PARENTS_ORGANIZE_BY_PARENT ] ])

  ]

  cattr_reader :available_view_options

    self.view_options ||=  { 'show_parents' => 'do_not_show' }

  def set_view_option( option, value)

    self.view_options[option] = value

  end

  def values_for_view_option( option)

    @@available_view_options.find { |vo| vo.name == option }.available_values

  end

  def caption_for_view_option( option)

    @@available_view_options.find { |vo| vo.name == option }.caption

  end

  include Comparable

    <% if authorize_for('timelog', 'edit') && @issue.leaf? %>

<!-- This function is needed for get ID from the text field with parent issue selection. -->

<script type="text/javascript">

  //<![CDATA[

  function setParentIssueValue(element, value) {

          document.getElementById('parent_issue_id').value = value.id;

      }

//]]>

</script>

<% if (@issue.new_record? || @allowed_statuses.any?) %>

<% if @issue.new_record? ||  @issue.leaf? %>	

<% else %>

<p><label><%= l(:field_start_date) %></label> <%= format_date(@issue.start_date) %></p>

<p><label><%= l(:field_due_date) %></label> <%= format_date(@issue.due_date) %></p>

<p><label><%= l(:field_done_ratio) %></label> <%= "#{@issue.done_ratio}%" %></p>

<% end %>

<%= content_tag( :input, {}, 

		 :id => :parent_issue_id,

		 :type => :hidden,

		 :name => 'parent_issue_id', :value => @parent_issue ? @parent_issue.id : "") %>

<p><label><%= l(:field_parent_issue) %></label>

<% if authorize_for( 'issues', 'add_subissue') %>

  <%= text_field_with_auto_complete( :issue, :parent,

				     { :name => 'issue_parent', :value => @parent_issue || "" },

				     :url => { :action => 'auto_complete_for_issue_parent', :project_id => @project},

				     :after_update_element => 'setParentIssueValue') %>

<% else %>

  <%= @parent_issue || "-" %>

<% end %>

</p>

<% if @issue.leaf? %>

<% else %>

<p><label><%= l(:field_done_ratio) %></label> <%= "#{@issue.done_ratio}%" %></p>

<% end %>

<% form_tag({}) do -%>

  <table class="list issues">

                :title => "#{l(:button_check_all)}/#{l(:button_uncheck_all)}" %>

	<%= sort_header_tag('id', :caption => '#', :default_order => 'desc') %>

      </tr></thead>

    <tbody>

      <% if query.view_options['show_parents'] == Query::VIEW_OPTIONS_SHOW_PARENTS_NEVER -%>

	  <%= issue_content( issue, query) %>

      <% elsif query.view_options['show_parents'] == Query::VIEW_OPTIONS_SHOW_PARENTS_ALWAYS -%>

	<% issues.each do |issue| -%>

	  <% issue.ancestors.reverse.each do |parent_issue| -%>

	    <%= issue_content( parent_issue, query, :unfiltered => true) %>

	  <% end -%>

	  <%= issue_content( issue, query) %>

	<% end -%>

      <% elsif query.view_options['show_parents'] == Query::VIEW_OPTIONS_SHOW_PARENTS_ORGANIZE_BY_PARENT -%>

	<% parents_on_first_lvl = []

	   issues.each do |i|

	     if i.parent

	       first_parent = i.root

	     else

	       first_parent = i

	     end

	     parents_on_first_lvl += [ first_parent ] unless parents_on_first_lvl.include?( first_parent)

	   end -%>

	<% parents_on_first_lvl.each do |parent| -%>

	  <%= issues_family_content( parent, issues, query) %>

	<% end -%>

      <% end -%>

    </tbody>

  </table>

	<% if @issue && @issue.leaf? %>

	<% end %>

    <fieldset id="view"><legend><%= l(:label_view) %></legend>

      <%= render :partial => 'queries/view_options', :locals => {:query => @query } %>

    </fieldset>

      <%= render :partial => 'queries/filters', :locals => {:query => @query} %>

    </fieldset>

<%= link_to_if_authorized(l(:button_add_subissue),

			  { :controller => 'issues', :action => 'add_subissue',

			    :project_id => @project.id, :issue => { :parent_id => @issue.id }},

			  :class => 'icon icon-add') %>

   <% end %>

<% end %>

    <%

       unless @selected_tracker_ids.empty?

	 issues = version.fixed_issues.find(:all,

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

                                           :conditions => ["tracker_id in (#{@selected_tracker_ids.join(',')})"],

                                           :order => "#{Tracker.table_name}.position, #{Issue.table_name}.id") 

         issues = Issue.find_with_parents( issues.collect { |i| i.id })

       end

      <%= render_list_of_related_issues( issues, version) %>

<fieldset><legend><%= l(:label_view) %></legend>

  <%= render :partial => 'queries/view_options', :locals => {:query => query } %>

</fieldset>

<% query.view_options.each_key do |voption| -%>

  <%= query.caption_for_view_option( voption) %>:

  <%= select_tag( "view_options[#{voption}]",

		  options_for_select( query.values_for_view_option( voption),

				      query.view_options[voption])) %>

<% end %>

<% if @issues.size > 0 %>

<%= render_list_of_related_issues( @issues, @version) %>

  error_issue_can_have_only_one_parent: allows only one relation (a task can have only one parent).

  field_calendar_firstday: First day of week

  field_parent: Subproject of

  field_parent_issue: Child of

  field_parent_title: Parent page

  label_children: parent of

  label_parents: child of

  label_view_option_parents_do_not_show: Never

  label_view_option_parents_show_always: Always

  label_view_option_parents_show_and_group: Organize by parent

  label_view_option_show_parents: Show parents

  button_add_subissue: Add sub-issue

class AddQueriesViewOptions < ActiveRecord::Migration

  def self.up

    add_column :queries, :view_options, :text

  end

  def self.down

    remove_column :queries, :view_options

  end

end

class AddDefaultValueOfViewOptionQueries < ActiveRecord::Migration

  def self.up

    Query.find(:all).each do |q|

      q.view_options ||= { 'show_parents' => 'do_not_show' }

      q.save!

    end

  end

  def self.down

  end

end

class AddIssuesNestedSets < ActiveRecord::Migration

  # IssueRelation::TYPE_PARENTS was deleted

  TYPE_PARENTS = "parents"

  def self.up

    add_column :issues, :parent_id, :integer, :default => nil

    add_column :issues, :lft, :integer

    add_column :issues, :rgt, :integer

    Issue.reset_column_information

    say_with_time "fixing invalid issues" do

      Issue.find( :all).each do |issue|

        if !issue.valid? && issue.errors.on( :due_date)

          issue.due_date = issue.start_date

          issue.save!

        end

      end

    end

    say_with_time "rebuilding left & right indexes" do

      Issue.rebuild!

    end

    say_with_time(

      "converting subissues for using parent_id instead of IssueRelation") do 

      IssueRelation.find_all_by_relation_type( TYPE_PARENTS).each do |rel|

        rel.issue_from.move_to_child_of rel.issue_to.id

        rel.delete

      end

    end

  end

  def self.down

    raise ActiveRecord::IrreversibleMigration

  end

end

_gloc_rule_default: '|n| n==1 ? "" : "_plural" '

actionview_datehelper_select_day_prefix:

actionview_datehelper_select_month_names: January,February,March,April,May,June,July,August,September,October,November,December

actionview_datehelper_select_month_names_abbr: Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec

actionview_datehelper_select_month_prefix:

actionview_datehelper_select_year_prefix:

actionview_datehelper_time_in_words_day: 1 day

actionview_datehelper_time_in_words_day_plural: %d days

actionview_datehelper_time_in_words_hour_about: about an hour

actionview_datehelper_time_in_words_hour_about_plural: about %d hours

actionview_datehelper_time_in_words_hour_about_single: about an hour

actionview_datehelper_time_in_words_minute: 1 minute

actionview_datehelper_time_in_words_minute_half: half a minute

actionview_datehelper_time_in_words_minute_less_than: less than a minute

actionview_datehelper_time_in_words_minute_plural: %d minutes

actionview_datehelper_time_in_words_minute_single: 1 minute

actionview_datehelper_time_in_words_second_less_than: less than a second

actionview_datehelper_time_in_words_second_less_than_plural: less than %d seconds

actionview_instancetag_blank_option: Please select

activerecord_error_inclusion: is not included in the list

activerecord_error_exclusion: is reserved

activerecord_error_invalid: is invalid

activerecord_error_confirmation: doesn't match confirmation

activerecord_error_accepted: must be accepted

activerecord_error_empty: can't be empty

activerecord_error_blank: can't be blank

activerecord_error_too_long: is too long

activerecord_error_too_short: is too short

activerecord_error_wrong_length: is the wrong length

activerecord_error_taken: has already been taken

activerecord_error_not_a_number: is not a number

activerecord_error_not_a_date: is not a valid date

activerecord_error_greater_than_start_date: must be greater than start date

activerecord_error_not_same_project: doesn't belong to the same project

activerecord_error_circular_dependency: This relation would create a circular dependency

general_fmt_age: %d yr

general_fmt_age_plural: %d yrs

general_fmt_date: %%m/%%d/%%Y

general_fmt_datetime: %%m/%%d/%%Y %%I:%%M %%p

general_fmt_datetime_short: %%b %%d, %%I:%%M %%p

general_fmt_time: %%I:%%M %%p

general_text_No: 'No'

general_text_Yes: 'Yes'

general_text_no: 'no'

general_text_yes: 'yes'

general_lang_name: 'English'

general_csv_separator: ','

general_csv_decimal_separator: '.'

general_csv_encoding: ISO-8859-1

general_pdf_encoding: ISO-8859-1

general_day_names: Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday

general_first_day_of_week: '7'

notice_account_updated: Account was successfully updated.

notice_account_invalid_creditentials: Invalid user or password

notice_account_password_updated: Password was successfully updated.

notice_account_wrong_password: Wrong password

notice_account_register_done: Account was successfully created. To activate your account, click on the link that was emailed to you.

notice_account_unknown_email: Unknown user.

notice_can_t_change_password: This account uses an external authentication source. Impossible to change the password.

notice_account_lost_email_sent: An email with instructions to choose a new password has been sent to you.

notice_account_activated: Your account has been activated. You can now log in.

notice_successful_create: Successful creation.

notice_successful_update: Successful update.

notice_successful_delete: Successful deletion.

notice_successful_connection: Successful connection.

notice_file_not_found: The page you were trying to access doesn't exist or has been removed.

notice_locking_conflict: Data has been updated by another user.

notice_not_authorized: You are not authorized to access this page.

notice_email_sent: An email was sent to %s

notice_email_error: An error occurred while sending mail (%s)

notice_feeds_access_key_reseted: Your RSS access key was reset.

notice_failed_to_save_issues: "Failed to save %d issue(s) on %d selected: %s."

notice_no_issue_selected: "No issue is selected! Please, check the issues you want to edit."

notice_account_pending: "Your account was created and is now pending administrator approval."

notice_default_data_loaded: Default configuration successfully loaded.

notice_unable_delete_version: Unable to delete version.