Redmine

                              :conditions => ["(((start_date>=? and start_date<=?) or (due_date>=? and due_date<=?) or (start_date<? and due_date>?)) and start_date is not null and due_date is not null)", @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to]

                              )

      # Issues that don't have a due date but that are assigned to a version with a date

                              :order => "start_date, effective_date",

                              :conditions => ["(((start_date>=? and start_date<=?) or (effective_date>=? and effective_date<=?) or (start_date<? and effective_date>?)) and start_date is not null and due_date is null and effective_date is not null)", @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to]

                              )

      @issue_count = @query.issue_count

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

                              :order => sort_clause, 

                              :offset => @issue_pages.current.offset, 

                              :limit => limit)

  # Attributes that can be updated on workflow transition (without :edit permission)

  # TODO: make it configurable (at least per role)

  def edit

    update_issue_from_params

      @issues.each do |issue|

        issue.reload

        journal = issue.init_journal(User.current, params[:notes])

        issue.safe_attributes = attributes

        call_hook(:controller_issues_bulk_edit_before_save, { :params => params, :issue => issue })

        unless issue.save

    unless @selected_tracker_ids.empty?

      @versions.each do |version|

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

        @issues_by_version[version] = issues

      end

    end

      @data = Issue.by_tracker(@project)

      @report_title = l(:field_tracker)

    when "version"

      @rows = @project.shared_versions.sort

      @data = Issue.by_version(@project)

      @report_title = l(:field_version)

    @available_criterias = { 'project' => {:sql => "#{TimeEntry.table_name}.project_id",

                                          :klass => Project,

                                          :label => :label_project},

                                          :klass => Version,

                                          :label => :label_version},

                             'category' => {:sql => "#{Issue.table_name}.category_id",

      sql << " FROM #{TimeEntry.table_name}"

      sql << " LEFT JOIN #{Issue.table_name} ON #{TimeEntry.table_name}.issue_id = #{Issue.table_name}.id"

      sql << " LEFT JOIN #{Project.table_name} ON #{TimeEntry.table_name}.project_id = #{Project.table_name}.id"

      sql << " WHERE"

      sql << " (%s) AND" % sql_condition

      sql << " (spent_on BETWEEN '%s' AND '%s')" % [ActiveRecord::Base.connection.quoted_date(@from), ActiveRecord::Base.connection.quoted_date(@to)]

            flash[:notice] = l(:notice_successful_create)

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

          end

        end

      else

        respond_to do |format|

        value = format_date(detail.value.to_date) if detail.value

        old_value = format_date(detail.old_value.to_date) if detail.old_value

        value = find_name_by_reflection(field, detail.value)

        old_value = find_name_by_reflection(field, detail.old_value)

                  l(:field_subject),

                  l(:field_assigned_to),

                  l(:field_category),

                  l(:field_author),

                  l(:field_start_date),

                  l(:field_due_date),

                  issue.subject,

                  issue.assigned_to,

                  issue.category,

                  issue.author.name,

                  format_date(issue.start_date),

                  format_date(issue.due_date),

    begin

      # Total issue count

      Issue.count(:group => criteria,

      # Open issues count

      Issue.count(:group => criteria,

                  :include => :status,

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

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

      # 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

      end

      issue.project = new_project

      if issue.parent && issue.parent.project_id != issue.project_id

    category_id

    assigned_to_id

    priority_id

    subject

    description

    start_date

      errors.add :start_date, :invalid

    end

    # Checks that the issue can not be added/moved to a disabled tracker

    if project && (tracker_id_changed? || project_id_changed?)

      unless project.trackers.include?(tracker)

  # Versions that the issue can be assigned to

  def assignable_versions

  end

  # Returns true if this issue is blocked by another issue that is still open

  # Returns the due date or the target due date if any

  # Used on gantt chart

  def due_before

  end

  # Returns the time scheduled for this issue.

  # Unassigns issues from +version+ if it's no longer shared with issue's project

  def self.update_versions_from_sharing_change(version)

    # Update issues assigned to the version

  end

  # Unassigns issues from versions that are no longer shared

  end

  def self.by_version(project)

  end

  def self.by_priority(project)

    count_and_group_by(:project => project,

                       :field => 'priority_id',

  end

  # Update issues so their versions are not pointing to a

  def self.update_versions(conditions=nil)

    # a different project and that is not systemwide shared

                                                conditions),

              ).each do |issue|

      end

    end

  end

    # Check that there is no issue of a non descendant project that is assigned

    # to one of the project or descendant versions

    v_ids = self_and_descendants.collect {|p| p.version_ids}.flatten

                                        :conditions => ["(#{Project.table_name}.lft < ? OR #{Project.table_name}.rgt > ?)" +

      return false

    end

    Project.transaction do

      new_issue = Issue.new

      new_issue.copy_from(issue)

      new_issue.project = self

      # project and the versions for self are not yet saved

      end

      # Reassign the category by name, since names are unique per

      # project and the categories for self are not yet saved

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

    QueryColumn.new(:updated_on, :sortable => "#{Issue.table_name}.updated_on", :default_order => 'desc'),

    QueryColumn.new(:category, :sortable => "#{IssueCategory.table_name}.name", :groupable => true),

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

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

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

        @available_filters["category_id"] = { :type => :list_optional, :order => 6, :values => @project.issue_categories.collect{|s| [s.name, s.id.to_s] } }

      end

      unless @project.shared_versions.empty?

      end

      unless @project.descendants.active.empty?

        @available_filters["subproject_id"] = { :type => :list_subprojects, :order => 13, :values => @project.descendants.visible.collect{|s| [s.name, s.id.to_s] } }

      # global filters for cross project issue list

      system_shared_versions = Version.visible.find_all_by_sharing('system')

      unless system_shared_versions.empty?

      end

      add_custom_fields_filters(IssueCustomField.find(:all, :conditions => {:is_filter => true, :is_for_all => true}))

    end

        db_field = 'user_id'

        sql << "#{Issue.table_name}.id #{ operator == '=' ? 'IN' : 'NOT IN' } (SELECT #{db_table}.watchable_id FROM #{db_table} WHERE #{db_table}.watchable_type='Issue' AND "

        sql << sql_for_field(field, '=', v, db_table, db_field) + ')'

      else

        # regular field

        db_table = Issue.table_name

class Version < ActiveRecord::Base

  after_update :update_issues_from_sharing_change

  belongs_to :project

  acts_as_customizable

  acts_as_attachable :view_permission => :view_files,

                     :delete_permission => :manage_files

  # Returns the total reported time for this version

  def spent_hours

  end

  def closed?

  # Returns the total amount of open issues for this version.

  def open_issues_count

  end

  # Returns the total amount of closed issues for this version.

  def closed_issues_count

  end

  def wiki_page

  # Returns the average estimated time of assigned issues

  # or 1 if no issue has an estimated time

  def estimated_average

    if @estimated_average.nil?

      average = fixed_issues.average(:estimated_hours).to_f

                     :title => l(:label_issue_category_new), 

                     :tabindex => 199) if authorize_for('issue_categories', 'new') %></p>

<% end %>

</div>

<div class="splitcontentright">

<% if Issue.use_field_for_done_ratio? %>

<p><%= f.select :done_ratio, ((0..10).to_a.collect {|r| ["#{r*10} %", r*10] }) %></p>

<% end %>

</div>

</div>

                                options_from_collection_for_select(@project.issue_categories, :id, :name)) %>

</p>

<p>

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

                                   version_options_for_select(@project.shared_versions.open)) %>

</p>

	</li>

	<% unless @project.nil? || @project.shared_versions.open.empty? -%>

	<li class="folder">			

		<ul>

		<% @project.shared_versions.open.sort.each do |v| -%>

		<% end -%>

		</ul>

	</li>

	<% end %>

		 	xml.author(:id => issue.author_id, :name => issue.author.name) unless issue.author.nil?

		 	xml.assigned_to(:id => issue.assigned_to_id, :name => issue.assigned_to.name) unless issue.assigned_to.nil?

		  xml.category(:id => issue.category_id, :name => issue.category.name) unless issue.category.nil?

      xml.parent(:id => issue.parent_id) unless issue.parent.nil?

      xml.subject 		issue.subject

    <td class="spent-time"><%= @issue.spent_hours > 0 ? (link_to l_hours(@issue.spent_hours), {:controller => 'timelog', :action => 'details', :project_id => @project, :issue_id => @issue}) : "-" %></td>

    <% end %>

</tr>

<%= render_custom_fields_rows(@issue) %>

<%= call_hook(:view_issues_show_details_bottom, :issue => @issue) %>

</table>

<hr />

<div class="contextual">

<%= link_to_remote_if_authorized(l(:button_quote), { :url => {:action => 'reply', :id => @issue} }, :class => 'icon icon-comment') unless @issue.description.blank? %>

</div>

<p><strong><%=l(:field_description)%></strong></p>

<div class="wiki">

<%= textilizable @issue, :description, :attachments => @issue.attachments %>

 	xml.author(:id => @issue.author_id, :name => @issue.author.name) unless @issue.author.nil?

 	xml.assigned_to(:id => @issue.assigned_to_id, :name => @issue.assigned_to.name) unless @issue.assigned_to.nil?

  xml.category(:id => @issue.category_id, :name => @issue.category.name) unless @issue.category.nil?

  xml.parent(:id => @issue.parent_id) unless @issue.parent.nil?

  xml.subject 		@issue.subject

<li><%=l(:field_priority)%>: <%=h issue.priority %></li>

<li><%=l(:field_assigned_to)%>: <%=h issue.assigned_to %></li>

<li><%=l(:field_category)%>: <%=h issue.category %></li>

<% issue.custom_values.each do |c| %>

  <li><%=h c.custom_field.name %>: <%=h show_value(c) %></li>

<% end %>

<%=l(:field_priority)%>: <%= issue.priority %>

<%=l(:field_assigned_to)%>: <%= issue.assigned_to %>

<%=l(:field_category)%>: <%= issue.category %>

<% issue.custom_values.each do |c| %><%= c.custom_field.name %>: <%= show_value(c) %>

<% end %>

<div class="splitcontentright">

<h3><%=l(:field_version)%>&nbsp;&nbsp;<%= link_to image_tag('zoom_in.png'), :action => 'issue_report_details', :detail => 'version' %></h3>

<br />

<% if @project.children.any? %>

<h3><%=l(:field_subproject)%>&nbsp;&nbsp;<%= link_to image_tag('zoom_in.png'), :action => 'issue_report_details', :detail => 'subproject' %></h3>

                                        :action => 'index',

                                        :project_id => version.project,

                                        :set_filter => 1,

                                        "#{criteria}_id" => count[:group]} %>

        </td>

        <td width="240px">

<% if version.fixed_issues.count > 0 %>

    <%= progress_bar([version.closed_pourcent, version.completed_pourcent], :width => '40em', :legend => ('%0.0f%' % version.completed_pourcent)) %>

    <p class="progress-info">

        (<%= '%0.0f' % (version.closed_issues_count.to_f / version.fixed_issues.count * 100) %>%)

         

        (<%= '%0.0f' % (version.open_issues_count.to_f / version.fixed_issues.count * 100) %>%)

    </p>

<% else %>

  field_password: Password

  field_new_password: New password

  field_password_confirmation: Confirmation

  field_type: Type

  field_host: Host

  field_port: Port

    map.permission :view_issue_watchers, {}

    map.permission :add_issue_watchers, {:watchers => :new}

    map.permission :delete_issue_watchers, {:watchers => :destroy}

  end

  map.project_module :time_tracking do |map|