subissues.diff - Redmine

     class IssuesController < ApplicationController
       menu_item :new_issue, :only => :new
       before_filter :find_issue, :only => [:show, :edit, :reply, :destroy_attachment]
       before_filter :find_issue_and_project_id, :only => [ :show_children, :hide_children ]
       before_filter :find_issue, :only => [:show, :edit, :reply, :destroy_attachment, :update_subject ]
       before_filter :find_issues, :only => [:bulk_edit, :move, :destroy]
       before_filter :find_project, :only => [:new, :update_form, :preview, :gantt, :calendar]
       before_filter :authorize, :except => [:index, :changes, :preview, :update_form, :context_menu]
       before_filter :find_project, :only => [:new, :auto_complete_for_issue_parent, :add_subissue, :update_form, :preview, :gantt, :calendar]
       before_filter :authorize, :except => [:index, :changes, :preview, :update_form, :context_menu, :show_children, :hide_children, :auto_complete_for_issue_parent ]
       before_filter :find_optional_project, :only => [:index, :changes]
       accept_key_auth :index, :changes
-...
       include SortHelper
       include IssuesHelper
       helper :timelog
       include ActionView::Helpers::PrototypeHelper
       def update_subject
         @notes = params[:notes]
         journal = @issue.init_journal(User.current, @notes)
         @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
         # User can change issue attributes only if he has :edit permission or if a workflow transition is allowed
         if (@edit_allowed || !@allowed_statuses.empty?) && params[:subject]
           @issue.subject = params[:subject]
         end
         if @issue.save
           if !journal.new_record?
             # Only send notification if something was actually changed
             flash[:notice] = l(:notice_successful_update)
             Mailer.deliver_issue_edit(journal) if Setting.notified_events.include?('issue_updated')
           end
           render(:text => params[:subject])
         end
       rescue ActiveRecord::StaleObjectError
         # Optimistic locking exception
         flash.now[:error] = l(:notice_locking_conflict)
       end
       def show_children
         retrieve_query
         if @query.valid?
           render :update do |page|
             page.replace "issue-#{@issue.id}", :partial => 'show_children', :locals => {:issue => @issue, :query => @query}
           end
         end
       end
       def hide_children
         retrieve_query #verificar necessidade
         if @query.valid?
           render :update do |page|
             page.select(".issue-#{@issue.id}-child").each do |child|
               child.remove
             end
             page.select("#issue-#{@issue.id} a.contract-link").each do |contractIcon|
               contractIcon.replace link_to_remote(image_tag("expand.png", :class=>'expand-icon'), {:url => {:controller => 'issues', :action => "show_children", :id => @issue, :project_id => @project}}, :class=>'expand-link')
             end
           end
         end
       end
       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
       def index
         sort_init "#{Issue.table_name}.id", "desc"
-...
           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
           @issues = Issue.find_with_parents( :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 => "#{@project || Setting.app_title}: #{l(:label_issue_plural)}") }
-...
         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
         @parent_issue = Issue.find( params[:issue_parent_issue_id]) unless params[:issue_parent_issue_id].blank?
         if request.get? || request.xhr?
           @issue.start_date ||= Date.today
         else
-...
           # Check that the user is allowed to apply the requested status
           @issue.status = (@allowed_statuses.include? requested_status) ? requested_status : default_status
           if @issue.save
             set_parent( @issue, params[:issue_parent_issue_id]) if params[:issue_parent_issue_id]
             attach_files(@issue, params[:attachments])
             flash[:notice] = l(:notice_successful_create)
             Mailer.deliver_issue_add(@issue) if Setting.notified_events.include?('issue_added')
-...
         @priorities = Enumeration::get_values('IPRI')
         render :layout => !request.xhr?
       end
       def add_subissue
         if params[:issue_parent_issue_id].nil?
           flash.now[:error] = 'No parent issue specified.'
           render :nothing => true, :layout => true
           return
         else
           redirect_to( :controller => 'issues', :action => 'new',
                        :issue_parent_issue_id => params[:issue_parent_issue_id])
           return
         end
       end
       # Attributes that can be updated on workflow transition (without :edit permission)
       # TODO: make it configurable (at least per role)
-...
           attachments = attach_files(@issue, params[:attachments])
           attachments.each {|a| journal.details << JournalDetail.new(:property => 'attachment', :prop_key => a.id, :value => a.filename)}
           if (@time_entry.hours.nil? || @time_entry.valid?) && @issue.save
             set_parent(@issue, params[:issue_parent_issue_id]) if params[:issue_parent_issue_id]
             # Log spend time
             if current_role.allowed_to?(:log_time)
               @time_entry.save
-...
             call_hook(:controller_issues_bulk_edit_before_save, { :params => params, :issue => issue })
             # Don't save any change to the issue if the user is not authorized to apply the requested status
             if (status.nil? || (issue.status.new_status_allowed_to?(status, current_role, issue.tracker) && issue.status = status)) && issue.save
               set_parent(issue, params[:issue_parent_issue_id]) unless params[:issue_parent_issue_id].blank?
               # Send notification for each issue (if changed)
               Mailer.deliver_issue_edit(journal) if journal.details.any? && Setting.notified_events.include?('issue_updated')
             else
-...
       def update_form
         @issue = Issue.new(params[:issue])
         @parent_issue = @issue.parent
         render :action => :new, :layout => false
       end
-...
     private
       def find_issue
         @issue = Issue.find(params[:id], :include => [:project, :tracker, :status, :author, :priority, :category])
         @parent_issue = @issue.parent
         @project = @issue.project
       rescue ActiveRecord::RecordNotFound
         render_404
       end
       def find_issue_and_project_id
         @issue = Issue.find( params[:id], :include => [:project, :tracker, :status, :author, :priority, :category])
         @parent_issue = @issue.parent
         @project = Project.find( params[:project_id])
       rescue ActiveRecord::RecordNotFound
         render_404
       end
       # Filter for bulk operations
       def find_issues
         @issues = Issue.find_all_by_id(params[:id] || params[:ids])

       helper :repositories
       include RepositoriesHelper
       include ProjectsHelper
       helper :versions
       include VersionsHelper
       # Lists visible projects
       def index
-...
           @selected_tracker_ids = selectable_trackers.collect {|t| t.id.to_s }
         end
       end
       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
     end

       before_filter :find_project, :authorize
       def show
         @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})
       end
       def edit

     module IssuesHelper
       include ApplicationHelper
       def issue_ancestors(issue=@issue)
         ancestors = ""
         return "" if issue.parent == nil
         ancestors += "issue-#{issue.parent.id}-child " + issue_ancestors(issue.parent)
       end
       def render_issue_tooltip(issue)
         @cached_label_start_date ||= l(:field_start_date)
-...
         export.rewind
         export
       end
       def set_parent(issue, parent_id)
         if (issue && parent_id.to_s.size > 0)
           issue.relations_from.each do |relation|
             if relation.relation_type == IssueRelation::TYPE_PARENTS
               relation.destroy
             end
           end
           issue.reload
           IssueRelation.create do |relation|
             relation.issue_from = issue
             relation.issue_to = Issue.find(parent_id)
             relation.relation_type = IssueRelation::TYPE_PARENTS
             unless relation.save
               flash[:error] = "Can't set ##{parent_id} as parent for the issue."
             end
           end unless parent_id == '0'
         end
       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
     end

     # -*- coding: mule-utf-8 -*-
     # redMine - project management software
     # Copyright (C) 2006-2007  Jean-Philippe Lang
+    #
-...
           else
             case column.name
             when :subject
             h((@project.nil? || @project != issue.project) ? "#{issue.project.name} - " : '') +
               link_to(h(value), :controller => 'issues', :action => 'show', :id => issue)
               subject_in_tree(issue, value)
             when :done_ratio
               progress_bar(value, :width => '80px')
             when :fixed_version
-...
           end
         end
       end
       def subject_in_tree(issue, value)
         image = ""
         unless issue.edge? #don't show + or - icons for leaf issues
           #o controle das tarefas a ser mostradas não está sendo feito por _list? verificar
           image = @show_all_issues ||
           @show_children ?
           link_to_remote(image_tag("contract.png", :class=>'contract-icon'), {:url => {:controller => 'issues', :action => "hide_children", :id => issue, :project_id => @project}}, :class=>'contract-link') :
           link_to_remote(image_tag("expand.png", :class=>'expand-icon'), {:url => {:controller => 'issues', :action => "show_children", :id => issue, :project_id => @project}}, :class=>'expand-link')
         end
         content_tag('span', image + content_tag('div', subject_text(issue, value), :class=>'issue-subject'), :class=>"issue-subject-level-#{issue.hierarchical_level}")
       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
     end

       def status_by_options_for_select(value)
         options_for_select(STATUS_BY_CRITERIAS.collect {|criteria| [l("field_#{criteria}".to_sym), criteria]}, value)
       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[:style] = 'opacity: 0.5;filter: alpha(opacity=50);'
             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
     end

     class Issue < ActiveRecord::Base
       belongs_to :project
       belongs_to :tracker
       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'
       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 :journals, :as => :journalized, :dependent => :destroy
       has_many :attachments, :as => :container, :dependent => :destroy
       has_many :journals,    :as => :journalized, :dependent => :destroy
       has_many :attachments, :as => :container,   :dependent => :destroy
       has_many :time_entries, :dependent => :delete_all
       has_and_belongs_to_many :changesets, :order => "#{Changeset.table_name}.committed_on ASC, #{Changeset.table_name}.id ASC"
       has_many :relations_from, :class_name => 'IssueRelation', :foreign_key => 'issue_from_id', :dependent => :delete_all
       has_many :relations_to, :class_name => 'IssueRelation', :foreign_key => 'issue_to_id', :dependent => :delete_all
       has_many :relations_to,   :class_name => 'IssueRelation', :foreign_key => 'issue_to_id',   :dependent => :delete_all
       acts_as_customizable
       acts_as_watchable
-...
       acts_as_activity_provider :find_options => {:include => [:project, :author, :tracker]}
       validates_presence_of :subject, :description, :priority, :project, :tracker, :author, :status
       validates_length_of :subject, :maximum => 255
       validates_inclusion_of :done_ratio, :in => 0..100
       validates_presence_of     :subject,    :description,   :priority, :project, :tracker, :author, :status
       validates_length_of       :subject,    :maximum => 255
       validates_inclusion_of    :done_ratio, :in => 0..100
       validates_numericality_of :estimated_hours, :allow_nil => true
       def after_initialize
-...
         return true
       end
       def priority_id=(pid)
         self.priority = nil
         write_attribute(:priority_id, pid)
       end
       def estimated_hours=(h)
         write_attribute :estimated_hours, (h.is_a?(String) ? h.to_hours : h)
       end
-...
         if start_date && soonest_start && start_date < soonest_start
           errors.add :start_date, :activerecord_error_invalid
         end
         if IssueStatus.find_by_id( @attributes['status_id']).is_closed? && children.find { |i| !i.closed? }
           errors.add :status, "Can't close parent issue while on of the children still is open."
         end
         unless children.empty?
           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
       end
       def validate_on_create
-...
             @current_journal.details << JournalDetail.new(:property => 'attr',
                                                           :prop_key => c,
                                                           :old_value => @issue_before_change.send(c),
                                                           :value => send(c)) unless send(c)==@issue_before_change.send(c)
                                                           :value => send(c)) unless send(c)==@issue_before_change.send(c) || (!self.edge? && %w(status_id priority_id fixed_version_id start_date due_date done_ratio estimated_hours).include?(c))
+          }
           # custom fields changes
           custom_values.each {|c|
-...
+          }
           @current_journal.save
         end
         # Save the issue even if the journal is not saved (because empty)
         true
       end
-...
         # Update start/due dates of following issues
         relations_from.each(&:set_issue_to_dates)
         # Set default status of parent if new status openes the issue.
         relations_from.each do |relation|
           if relation.relation_type == IssueRelation::TYPE_PARENTS
             relation.set_issue_to_default_status
             relation.set_issue_to_target_version
           end
         end
         # Close duplicates if the issue was closed
         if @issue_before_change && !@issue_before_change.closed? && self.closed?
           duplicates.each do |duplicate|
-...
           end
         end
       end
       def init_journal(user, notes = "")
         @current_journal ||= Journal.new(:journalized => self, :user => user, :notes => notes)
         @issue_before_change = self.clone
-...
         @current_journal
       end
       def priority_id=(pid)
         self.priority = nil
         write_attribute(:priority_id, pid)
       end
       # Return true if the issue is closed, otherwise false
       def closed?
         self.status.is_closed?
-...
       # Returns the due date or the target due date if any
       # Used on gantt chart
       def due_before
         due_date || (fixed_version ? fixed_version.effective_date : nil)
         due_date || (fixed_version ? fixed_version.effective_date : 0)
       end
       def duration1
         (start_date && due_date) ? (due_date - start_date + 1) : 0
       end
       def duration
-...
         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 start_date
         calculate 'start_date'
       end
       def due_date
         calculate 'due_date'
       end
       def calculate(field)
         if children?
           @value = eval "children.first.#{field}"
           children.each do |child|
             case field
               when 'start_date'
               if child.start_date && (!@value || @value > child.start_date)
                 @value = child.start_date
               end
               when 'due_date'
               if child.due_date && (!@value || @value < child.due_date)
                 @value = child.due_date
               end
             end
           end
           @value
         else
           read_attribute(eval(":#{field}"))
         end
       end
       def children?
         children != []
       end
       def children
         children = []
         relations_to.each do |relation|
           if relation.relation_type == IssueRelation::TYPE_PARENTS
             children << relation.other_issue(self)
           end
         end
         children
       end
       def parent
         relations_from.each do |relation|
           if relation.relation_type == IssueRelation::TYPE_PARENTS
             return parent = relation.other_issue(self)
           end
         end
         return nil
       end
       def parent?
         parent != nil
       end
       def root?
         !parent?
       end
       def ancestors(issue=self)
         a = []
         return a if ! issue.parent?
         (a << issue.parent) | ancestors(issue.parent)
       end
       #First level tasks have hierarchical level = 1 and so on
       def hierarchical_level(issue=self)
         issue.parent? ? (1 + hierarchical_level(issue.parent)) : 1
       end
       def edge?
         relations_to.each do |relation|
           if relation.relation_type == IssueRelation::TYPE_PARENTS
             return false
           end
         end
         return true
       end
       def orphan?
         root? && edge?
       end
       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
       def to_s
         "#{tracker} ##{id}: #{subject}"
       end

     class IssueRelation < ActiveRecord::Base
       belongs_to :issue_from, :class_name => 'Issue', :foreign_key => 'issue_from_id'
       belongs_to :issue_to, :class_name => 'Issue', :foreign_key => 'issue_to_id'
       belongs_to :issue_to,   :class_name => 'Issue', :foreign_key => 'issue_to_id'
       TYPE_RELATES      = "relates"
       TYPE_DUPLICATES   = "duplicates"
       TYPE_BLOCKS       = "blocks"
       TYPE_PRECEDES     = "precedes"
       TYPE_PARENTS      = "parents"
       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 },
       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 },
                 TYPE_PARENTS    => { :name => :label_parents,    :sym_name => :label_children,      :order => 5 },
               }.freeze
       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
       validates_presence_of     :issue_from,    :issue_to, :relation_type
       validates_inclusion_of    :relation_type, :in        => TYPES.keys
       validates_uniqueness_of   :relation_type, :scope     => [:issue_from_id, :relation_type], :message=>l(:error_issue_can_have_only_one_parent)
       validates_numericality_of :delay,         :allow_nil => true
       validates_uniqueness_of   :issue_to_id,   :scope     => :issue_from_id
       def validate
         if issue_from && issue_to
-...
         else
           self.delay = nil
         end
         # Set new status to parent if new status openes the issue.
         if TYPE_PARENTS == relation_type
           set_issue_to_default_status
           set_issue_to_target_version
         end
         set_issue_to_dates
       end
       def set_issue_to_default_status
         if issue_to.closed? && !issue_from.closed?
           issue_to.update_attribute :status, IssueStatus.default
         end
       end
       def set_issue_to_target_version
         if issue_to.fixed_version.nil? && issue_from.fixed_version or
             ( issue_to.fixed_version && issue_from.fixed_version and
               issue_to.fixed_version.project == issue_from.fixed_version.project and
               issue_to.fixed_version < issue_from.fixed_version )
           issue_to.update_attribute :fixed_version, issue_from.fixed_version
         end
       end
       def set_issue_to_dates
         soonest_start = self.successor_soonest_start

       validates_length_of :name, :maximum => 60
       validates_format_of :effective_date, :with => /^\d{4}-\d{2}-\d{2}$/, :message => 'activerecord_error_not_a_date', :allow_nil => true
       include Comparable
       def start_date
         effective_date
       end

             <%= render :partial => (@edit_allowed ? 'form' : 'form_update'), :locals => {:f => f} %>
             </fieldset>
         <% end %>
         <% if authorize_for('timelog', 'edit') %>
         <% if authorize_for('timelog', 'edit') && @issue.edge? %>
             <fieldset class="tabular"><legend><%= l(:button_log_time) %></legend>
             <% fields_for :time_entry, @time_entry, { :builder => TabularFormBuilder, :lang => current_language} do |time_entry| %>
             <div class="splitcontentleft">

     <!-- 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('issue_parent_issue_id').value = value.id;
+          }
     //]]>
     </script>
     <% if @issue.new_record? %>
     <p><%= f.select :tracker_id, @project.trackers.collect {|t| [t.name, t.id]}, :required => true %></p>
     <%= observe_field :issue_tracker_id, :url => { :action => :new },
-...
     </div>
     <div class="splitcontentleft">
     <% if @issue.new_record? || @allowed_statuses.any? %>
     <% if (@issue.new_record? || @allowed_statuses.any?) %>
     <p><%= f.select :status_id, (@allowed_statuses.collect {|p| [p.name, p.id]}), :required => true %></p>
     <% else %>
     <p><label><%= l(:field_status) %></label> <%= @issue.status.name %></p>
     <% end %>
     <p><%= f.select :priority_id, (@priorities.collect {|p| [p.name, p.id]}), :required => true %></p>
     <p><%= f.select :assigned_to_id, (@issue.assignable_users.collect {|m| [m.name, m.id]}), :include_blank => true %></p>
     <p><%= f.select :category_id, (@project.issue_categories.collect {|c| [c.name, c.id]}), :include_blank => true %>
     <%= prompt_to_remote(l(:label_issue_category_new),
-...
     </div>
     <div class="splitcontentright">
     <% if @issue.edge? %>
     <p><%= f.text_field :start_date, :size => 10 %><%= calendar_for('issue_start_date') %></p>
     <p><%= f.text_field :due_date, :size => 10 %><%= calendar_for('issue_due_date') %></p>
     <p><%= f.text_field :estimated_hours, :size => 3 %> <%= l(:field_hours) %></p>
     <p><%= f.select :done_ratio, ((0..10).to_a.collect {|r| ["#{r*10} %", r*10] }) %></p>
     <% 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 => :issue_parent_issue_id,
     		 :type => :hidden,
     		 :name => 'issue_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>
     </div>
     <div style="clear:both;"> </div>

     <p><%= f.select :assigned_to_id, (@issue.assignable_users.collect {|m| [m.name, m.id]}), :include_blank => true %></p>
     </div>
     <div class="splitcontentright">
     <% if @issue.edge? %>
     <p><%= f.select :done_ratio, ((0..10).to_a.collect {|r| ["#{r*10} %", r*10] }) %></p>
     <% else %>
     <p><label><%= l(:field_done_ratio) %></label> <%= "#{@issue.done_ratio}%" %></p>
     <% end %>
     <%= content_tag('p', f.select(:fixed_version_id,
                               (@project.versions.sort.collect {|v| [v.name, v.id]}),
                               { :include_blank => true })) unless @project.versions.empty? %>

             <% end %>
     	</tr></thead>
     	<tbody>
     	<% issues.each do |issue| -%>
     	<% issues.each do |issue|
     	   next if !@show_all_issues && (issue.hierarchical_level != 1) -%>
     	<tr id="issue-<%= issue.id %>" class="issue hascontextmenu <%= cycle('odd', 'even') %> <%= "status-#{issue.status.position} priority-#{issue.priority.position}" %>">
     	    <td class="checkbox"><%= check_box_tag("ids[]", issue.id, false, :id => nil) %></td>
     		<td><%= link_to issue.id, :controller => 'issues', :action => 'show', :id => issue %></td>

     <%
     issues = [@issue]
     issues += @issue.children
     issues.each do |issue|
     	is_parent = (issue == @issue)
         #used in queries_helper.rb when deciding which icon will be shown (if + or -)
     	@show_children = is_parent -%>
     	<tr id="issue-<%=issue.id%>" class="issue <%= issue_ancestors(issue) %> hascontextmenu <%= cycle('odd', 'even') %> <%= "status-#{issue.status.position} priority-#{issue.priority.position}" %>">
     	    <td class="checkbox"><%= check_box_tag("ids[]", issue.id, false, :id => nil) %></td>
     		<td><%= link_to issue.id, :controller => 'issues', :action => 'show', :id => issue %></td>
     	    <% query.columns.each do |column| %><%= content_tag 'td', column_content(column, issue), :class => column.name %><% end %>
     	</tr>
     <% end -%>

     	<li><%= context_menu_link l(:button_edit), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id)},
     	        :class => 'icon-edit', :disabled => !@can[:edit] %></li>
     <% end %>
     	<li class="folder">
     		<a href="#" class="submenu"><%= l(:field_priority) %></a>
     		<ul>
-...
     		</ul>
     	</li>
     	<% end -%>
     	<% if @issue && @issue.edge? %>
     	<li class="folder">
     		<a href="#" class="submenu"><%= l(:field_done_ratio) %></a>
     		<ul>
-...
     		<% end -%>
     		</ul>
     	</li>
     	<% end %>
     <% if !@issue.nil? %>
     	<li><%= context_menu_link l(:button_copy), {:controller => 'issues', :action => 'new', :project_id => @project, :copy_from => @issue},
     	        :class => 'icon-copy', :disabled => !@can[:copy] %></li>

        	pdf.Cell(30, row_height, l(:field_priority), 0, 0, 'L', 1)
        	pdf.Cell(40, row_height, l(:field_assigned_to), 0, 0, 'L', 1)
        	pdf.Cell(25, row_height, l(:field_updated_on), 0, 0, 'L', 1)
        	pdf.Cell(15, row_height, l(:field_parent_issue), 0, 0, 'L', 1)
        	pdf.Cell(0, row_height, l(:field_subject), 0, 0, 'L', 1)
        	pdf.Line(10, pdf.GetY, 287, pdf.GetY)
        	pdf.Ln
-...
     	   	pdf.Cell(30, row_height, issue.priority.name, 0, 0, 'L', 1)
     	   	pdf.Cell(40, row_height, issue.assigned_to ? issue.assigned_to.name : '', 0, 0, 'L', 1)
     	   	pdf.Cell(25, row_height, format_date(issue.updated_on), 0, 0, 'L', 1)
        		pdf.Cell(15, row_height, issue.parent ? "# #{issue.parent.id}" : '', 0, 0, 'L', 1)
     	   	pdf.MultiCell(0, row_height, (@project == issue.project ? issue.subject : "#{issue.project.name} - #{issue.subject}"))
        		pdf.Line(10, pdf.GetY, 287, pdf.GetY)
        		pdf.SetY(pdf.GetY() + 1)

     <div class="contextual">
     <%= link_to_if_authorized(l(:button_update), {:controller => 'issues', :action => 'edit', :id => @issue }, :onclick => 'showAndScrollTo("update", "notes"); return false;', :class => 'icon icon-edit', :accesskey => accesskey(:edit)) %>
     <%= link_to_if_authorized(l(:button_add_subissue),
     			  { :controller => 'issues', :action => 'add_subissue',
     			    :project_id => @project.id, :issue_parent_issue_id => @issue.id },
     			  :class => 'icon icon-add') %>
     <%= link_to_if_authorized(l(:button_update), {:controller => 'issues', :action => 'edit', :id => @issue, :project_id => @project }, :onclick => 'showAndScrollTo("update", "notes"); return false;', :class => 'icon icon-edit', :accesskey => accesskey(:edit)) %>
     <%= link_to_if_authorized l(:button_log_time), {:controller => 'timelog', :action => 'edit', :issue_id => @issue}, :class => 'icon icon-time' %>
     <%= watcher_tag(@issue, User.current) %>
     <%= link_to_if_authorized l(:button_copy), {:controller => 'issues', :action => 'new', :project_id => @project, :copy_from => @issue }, :class => 'icon icon-copy' %>
-...
        if (n > 1)
             n = 0 %>
             </tr><tr>
      <%end
     end %>
        <% end %>
     <% end %>
     </tr>
     <%= call_hook(:view_issues_show_details_bottom, :issue => @issue) %>
     </table>

         <%= render :partial => 'versions/overview', :locals => {:version => version} %>
         <%= render(:partial => "wiki/content", :locals => {:content => version.wiki_page.content}) if version.wiki_page %>
         <% 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") unless @selected_tracker_ids.empty?
         <%
            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
            issues ||= []
         %>
         <% if issues.size > 0 %>
         <fieldset class="related-issues"><legend><%= l(:label_related_issues) %></legend>
         <ul>
         <%- issues.each do |issue| -%>
             <li><%= link_to_issue(issue) %>: <%=h issue.subject %></li>
         <%- end -%>
         </ul>
           <%= render_list_of_related_issues( issues, version) %>
         </fieldset>
         <% end %>
     <% end %>

     <%= render :partial => 'versions/overview', :locals => {:version => @version} %>
     <%= render(:partial => "wiki/content", :locals => {:content => @version.wiki_page.content}) if @version.wiki_page %>
     <% issues = @version.fixed_issues.find(:all,
                                            :include => [:status, :tracker],
                                            :order => "#{Tracker.table_name}.position, #{Issue.table_name}.id") %>
     <% if issues.size > 0 %>
     <% if @issues.size > 0 %>
     <fieldset class="related-issues"><legend><%= l(:label_related_issues) %></legend>
     <ul>
     <% issues.each do |issue| -%>
         <li><%= link_to_issue(issue) %>: <%=h issue.subject %></li>
     <% end -%>
     </ul>
     <%= render_list_of_related_issues( @issues, @version) %>
     </fieldset>
     <% end %>
     </div>

     # Don't change this file!
     # Configure your app in config/environment.rb and config/environments/*.rb
     RAILS_ROOT = File.expand_path("#{File.dirname(__FILE__)}/..") unless defined?(RAILS_ROOT)
     RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
     module Rails
       class << self
-...
           def load_rubygems
             require 'rubygems'
             unless rubygems_version >= '0.9.4'
               $stderr.puts %(Rails requires RubyGems >= 0.9.4 (you have #{rubygems_version}). Please `gem update --system` and try again.)
             min_version = '1.1.1'
             unless rubygems_version >= min_version
               $stderr.puts %Q(Rails requires RubyGems >= #{min_version} (you have #{rubygems_version}). Please `gem update --system` and try again.)
               exit 1
             end
           rescue LoadError
             $stderr.puts %(Rails requires RubyGems >= 0.9.4. Please install RubyGems and try again: http://rubygems.rubyforge.org)
             $stderr.puts %Q(Rails requires RubyGems >= #{min_version}. Please install RubyGems and try again: http://rubygems.rubyforge.org)
             exit 1
           end

     field_assigned_to: Възложена на
     field_priority: Приоритет
     field_fixed_version: Планувана версия
     field_parent_issue: Child of
     field_user: Потребител
     field_role: Роля
     field_homepage: Начална страница
-...
     label_blocked_by: блокирана от
     label_precedes: предшества
     label_follows: изпълнява се след
     label_parents: child of
     label_children: parent of
     label_end_to_start: end to start
     label_end_to_end: end to end
     label_start_to_start: start to start
-...
     setting_default_projects_public: Новите проекти са публични по подразбиране
     error_scm_annotate: "Обектът не съществува или не може да бъде анотиран."
     label_planning: Планиране
     error_issue_can_have_only_one_parent: allows only one relationship (a task can have only one parent).
     text_subprojects_destroy_warning: 'Its subproject(s): %s will be also deleted.'
     label_and_its_subprojects: %s and its subprojects
     mail_body_reminder: "%d issue(s) that are assigned to you are due in the next %d days:"
-...
     text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."
     permission_edit_own_messages: Edit own messages
     permission_delete_own_messages: Delete own messages
     button_add_subissue: Add sub-issue
     field_calendar_firstday: First day of week

     text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."
     permission_edit_own_messages: Edit own messages
     permission_delete_own_messages: Delete own messages
     button_add_subissue: Add sub-issue
     label_parents: child of
     label_children: parent of
     field_parent_issue: Child of
     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_assigned_to: Přiřazeno
     field_priority: Priorita
     field_fixed_version: Přiřazeno k verzi
     field_parent_issue: Child of
     field_user: Uživatel
     field_role: Role
     field_homepage: Homepage
-...
     label_blocked_by: zablokován
     label_precedes: předchází
     label_follows: následuje
     label_parents: child of
     label_children: parent of
     label_end_to_start: od konce do začátku
     label_end_to_end: od konce do konce
     label_start_to_start: od začátku do začátku
-...
     enumeration_activities: Aktivity (sledování času)
     error_scm_annotate: "Položka neexistuje nebo nemůže být komentována."
     label_planning: Plánování
     error_issue_can_have_only_one_parent: allows only one relation (a task can have only one parent).
     text_subprojects_destroy_warning: 'Its subproject(s): %s will be also deleted.'
     label_and_its_subprojects: %s and its subprojects
     mail_body_reminder: "%d issue(s) that are assigned to you are due in the next %d days:"
-...
     text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."
     permission_edit_own_messages: Edit own messages
     permission_delete_own_messages: Delete own messages
     button_add_subissue: Add sub-issue
     field_calendar_firstday: First day of week

     field_assigned_to: Tildelt til
     field_priority: Prioritet
     field_fixed_version: Planlagt version
     field_parent_issue: Child of
     field_user: Bruger
     field_role: Rolle
     field_homepage: Hjemmeside
-...
     label_blocked_by: blokeret af
     label_precedes: kommer før
     label_follows: følger
     label_parents: child of
     label_children: parent of
     label_end_to_start: slut til start
     label_end_to_end: slut til slut
     label_start_to_start: start til start
-...
     label_chronological_order: I kronologisk rækkefølge
     label_reverse_chronological_order: I omvendt kronologisk rækkefølge
     label_planning: Planlægning
     error_issue_can_have_only_one_parent: allows only one relation (a task can have only one parent).
     label_incoming_emails: Indkommende e-mails
     label_generate_key: Generer en nøgle
     label_issue_watchers: Overvågere
-...
     text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."
     permission_edit_own_messages: Edit own messages
     permission_delete_own_messages: Delete own messages
     button_add_subissue: Add sub-issue
     field_calendar_firstday: First day of week

     field_assigned_to: Zugewiesen an
     field_priority: Priorität
     field_fixed_version: Zielversion
     field_parent_issue: Child of
     field_user: Benutzer
     field_role: Rolle
     field_homepage: Projekt-Homepage
-...
     label_blocked_by: Blockiert durch
     label_precedes: Vorgänger von
     label_follows: folgt
     label_parents: child of
     label_children: parent of
     label_end_to_start: Ende - Anfang
     label_end_to_end: Ende - Ende
     label_start_to_start: Anfang - Anfang
-...
     enumeration_issue_priorities: Ticket-Prioritäten
     enumeration_doc_categories: Dokumentenkategorien
     enumeration_activities: Aktivitäten (Zeiterfassung)
     error_issue_can_have_only_one_parent: allows only one relation (a task can have only one parent).
     button_add_subissue: Add sub-issue
     field_calendar_firstday: First day of week

     field_assigned_to: Assigned to
     field_priority: Priority
     field_fixed_version: Target version
     field_parent_issue: Child of
     field_user: User
     field_role: Role
     field_homepage: Homepage
-...
     field_default_value: Default value
     field_comments_sorting: Display comments
     field_parent_title: Parent page
     field_calendar_firstday: First day of week
     setting_app_title: Application title
     setting_app_subtitle: Application subtitle
     setting_welcome_text: Welcome text
-...
     label_blocked_by: blocked by
     label_precedes: precedes
     label_follows: follows
     label_parents: child of
     label_children: parent of
     label_end_to_start: end to start
     label_end_to_end: end to end
     label_start_to_start: start to start
-...
     button_test: Test
     button_edit: Edit
     button_add: Add
     button_add_subissue: Add sub-issue
     button_change: Change
     button_apply: Apply
     button_clear: Clear
-...
     text_regexp_info: eg. ^[A-Z0-9]+$
     text_min_max_length_info: 0 means no restriction
     text_project_destroy_confirmation: Are you sure you want to delete this project and related data ?
     error_issue_can_have_only_one_parent: allows only one relation (a task can have only one parent).
     text_subprojects_destroy_warning: 'Its subproject(s): %s will be also deleted.'
     text_workflow_edit: Select a role and a tracker to edit the workflow
     text_are_you_sure: Are you sure ?

     field_identifier: Identificador
     field_is_closed: Petición resuelta
     field_is_default: Estado por defecto
     field_is_filter: Usado como filtro
     field_is_for_all: Para todos los proyectos
     field_is_in_chlog: Consultar las peticiones en el histórico
     field_is_in_roadmap: Consultar las peticiones en el roadmap
     field_is_public: Público
-...
     field_user: Usuario
     field_value: Valor
     field_version: Versión
     field_parent: Proyecto padre
     field_parent_issue: Child of
     general_csv_decimal_separator: ','
     general_csv_encoding: ISO-8859-15
     general_csv_separator: ';'
-...
     label_workflow: Flujo de trabajo
     label_year: Año
     label_yesterday: ayer
     label_parents: child of
     label_children: parent of
     mail_body_account_activation_request: "Un nuevo usuario (%s) ha sido registrado. Esta cuenta está pendiende de aprobación"
     mail_body_account_information: Información sobre su cuenta
     mail_body_account_information_external: Puede usar su cuenta "%s" para conectarse.
-...
     project_module_time_tracking: Control de tiempo
     project_module_wiki: Wiki
     setting_activity_days_default: Días a mostrar en la actividad de proyecto
     setting_app_subtitle: Subtítulo de la aplicación
     setting_app_title: Título de la aplicación
     setting_attachment_max_size: Tamaño máximo del fichero
     setting_autofetch_changesets: Autorellenar los commits del repositorio
     setting_autologin: Conexión automática
     setting_bcc_recipients: Ocultar las copias de carbón (bcc)
     setting_commit_fix_keywords: Palabras clave para la corrección
     setting_commit_logs_encoding: Codificación de los mensajes de commit
     setting_commit_ref_keywords: Palabras clave para la referencia
     setting_cross_project_issue_relations: Permitir relacionar peticiones de distintos proyectos
     setting_date_format: Formato de la fecha
     setting_default_language: Idioma por defecto
     setting_default_projects_public: Los proyectos nuevos son públicos por defecto
     setting_display_subprojects_issues: Mostrar peticiones de un subproyecto en el proyecto padre por defecto
     setting_emails_footer: Pie de mensajes
     error_issue_can_have_only_one_parent: allows only one relation (a task can have only one parent).
     setting_enabled_scm: Activar SCM
     setting_feeds_limit: Límite de contenido para sindicación
     setting_gravatar_enabled: Usar iconos de usuario (Gravatar)
-...
     text_user_wrote: '%s escribió:'
     text_wiki_destroy_confirmation: ¿Seguro que quiere borrar el wiki y todo su contenido?
     text_workflow_edit: Seleccionar un flujo de trabajo para actualizar
     field_is_filter: Used as a filter
     setting_default_language: Default language
     setting_emails_footer: Emails footer
     setting_app_subtitle: Application subtitle
     button_add_subissue: Add sub-issue
     setting_cross_project_issue_relations: Allow cross-project issue relations
     setting_autofetch_changesets: Autofetch commits
     setting_attachment_max_size: Attachment max. size
     setting_app_title: Application title
     setting_date_format: Date format
     setting_default_projects_public: New projects are public by default
     setting_commit_fix_keywords: Fixing keywords
     setting_autologin: Autologin
     setting_display_subprojects_issues: Display subprojects issues on main projects by default
     setting_bcc_recipients: Blind carbon copy recipients (bcc)
     setting_commit_ref_keywords: Referencing keywords
     field_is_for_all: For all projects
     setting_commit_logs_encoding: Commit messages encoding
     field_calendar_firstday: First day of week

     text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."
     permission_edit_own_messages: Edit own messages
     permission_delete_own_messages: Delete own messages
     button_add_subissue: Add sub-issue
     label_parents: child of
     label_children: parent of
     field_parent_issue: Child of
     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_assigned_to: Assigné à
     field_priority: Priorité
     field_fixed_version: Version cible
     field_parent_issue: Child of
     field_user: Utilisateur
     field_role: Rôle
     field_homepage: Site web
-...
     label_blocked_by: bloqué par
     label_precedes: précède
     label_follows: suit
     label_parents: child of
     label_children: parent of
     label_end_to_start: fin à début
     label_end_to_end: fin à fin
     label_start_to_start: début à début
-...
     text_regexp_info: ex. ^[A-Z0-9]+$
     text_min_max_length_info: 0 pour aucune restriction
     text_project_destroy_confirmation: Etes-vous sûr de vouloir supprimer ce projet et toutes ses données ?
     error_issue_can_have_only_one_parent: allows only one relation (a task can have only one parent).
     text_subprojects_destroy_warning: 'Ses sous-projets: %s seront également supprimés.'
     text_workflow_edit: Sélectionner un tracker et un rôle pour éditer le workflow
     text_are_you_sure: Etes-vous sûr ?
-...
     enumeration_issue_priorities: Priorités des demandes
     enumeration_doc_categories: Catégories des documents
     enumeration_activities: Activités (suivi du temps)
     button_add_subissue: Add sub-issue
     field_calendar_firstday: First day of week

     field_assigned_to: מוצב ל
     field_priority: עדיפות
     field_fixed_version: גירסאת יעד
     field_parent_issue: Child of
     field_user: מתשמש
     field_role: תפקיד
     field_homepage: דף הבית
-...
     setting_default_projects_public: פרויקטים חדשים הינם פומביים כברירת מחדל
     error_scm_annotate: "הכניסה לא קיימת או שלא ניתן לתאר אותה."
     label_planning: תכנון
     error_issue_can_have_only_one_parent: allows only one relation (a task can have only one parent).
     text_subprojects_destroy_warning: 'Its subproject(s): %s will be also deleted.'
     label_and_its_subprojects: %s and its subprojects
     mail_body_reminder: "%d issue(s) that are assigned to you are due in the next %d days:"
-...
     text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."
     permission_edit_own_messages: Edit own messages
     permission_delete_own_messages: Delete own messages
     button_add_subissue: Add sub-issue
     label_parents: child of
     label_children: parent of
     field_calendar_firstday: First day of week

     text_repository_usernames_mapping: "Állítsd be a felhasználó összerendeléseket a Redmine, és a tároló logban található felhasználók között.\nAz azonos felhasználó nevek összerendelése automatikusan megtörténik."
     permission_edit_own_messages: Saját üzenetek szerkesztése
     permission_delete_own_messages: Saját üzenetek törlése
     button_add_subissue: Add sub-issue
     label_parents: child of
     label_children: parent of
     field_parent_issue: Child of
     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_assigned_to: Assegnato a
     field_priority: Priorita'
     field_fixed_version: Versione prevista
     field_parent_issue: Child of
     field_user: Utente
     field_role: Ruolo
     field_homepage: Homepage
-...
     label_blocked_by: bloccato da
     label_precedes: precede
     label_follows: segue
     label_parents: child of
     label_children: parent of
     label_end_to_start: end to start
     label_end_to_end: end to end
     label_start_to_start: start to start
-...
     setting_default_projects_public: I nuovi progetti sono pubblici per default
     error_scm_annotate: "L'oggetto non esiste o non può essere annotato."
     label_planning: Pianificazione
     error_issue_can_have_only_one_parent: allows only one relation (a task can have only one parent).
     text_subprojects_destroy_warning: 'Anche i suoi sottoprogetti: %s verranno eliminati.'
     label_and_its_subprojects: %s ed i suoi sottoprogetti
     mail_body_reminder: "%d segnalazioni che ti sono state assegnate scadranno nei prossimi %d giorni:"
-...
     text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."
     permission_edit_own_messages: Edit own messages
     permission_delete_own_messages: Delete own messages
     button_add_subissue: Add sub-issue
     field_calendar_firstday: First day of week