Redmine

    @issue.start_date ||= DateTime.now if Setting.default_issue_start_date_to_creation_date?

  def time_select_tag( name, stime, options = {} )

    time = stime.to_time(:utc)

    if time.nil?

      selected = {:hour => '', :min => ''}

    else

      zone = User.current.time_zone

      time = zone ? time.in_time_zone(zone) : (time.utc? ? time.localtime : time)

      selected = {:hour => time.hour, :min => time.min}

    end

    out = ''

    if options[:required]

      hours = []

      mins = []

    else

      hours = [['', '']]

      mins = [['', '']]

    end

    hours += (0..23).map{|i| ['%02d' % i, i] } # Zero pad

    out << select_tag(

      "#{name}[hour]",

      options_for_select( hours, selected[:hour] ),

      :style => 'min-width: 10px;max-width: 50px;'

    )

    out << ':'

    mins += (0..59).map{|i| ['%02d' % i, i] } # Zero pad

    out << select_tag(

      "#{name}[minute]",

      options_for_select( mins, selected[:min] ),

      :style => 'min-width: 10px;max-width: 50px;'

    )

  end

              case value.class.name

              when 'Time'

                if ( column.name == :start_date or column.name == :due_date ) and

                  ( !issue.project.use_datetime_for_issues or value.strftime('%H%M')=='0000' )

                  format_date(value)

                else

                  format_time(value)

                end

              else

                format_object(value)

              end

  attr_accessor :start_time

  attr_accessor :due_time

  #validates :start_date, :date => true

  #validates :due_date, :date => true

  #Note very well - before_save runs for both updates AND creations (also, before_create is called after before_save)

  before_save :close_duplicates, :update_done_ratio_from_issue_status,

              :force_updated_on_change, :update_closed_on, :set_assigned_to_was, :add_start_and_due_time

    'start_time',

    'due_time',    

    # Helper to make sure that when we load in the time it takes into account that it is supplied localised and must be converted back to utc.

    def load_localised_time(date, time, time_zone)

      localised_date = {:year => date.year, :month => date.month, :day => date.day}

      localised_datetime = date.in_time_zone(time_zone).change({:hour => time['hour'].to_i, :min => time['minute'].to_i})

      return localised_datetime.change(localised_date).utc

    end

    if (start_time = attrs.delete('start_time')) && safe_attribute?('start_time') && self.start_date.is_a?(Time)

      self.start_date = load_localised_time(self.start_date, start_time, user.time_zone)

    end

    if (due_time = attrs.delete('due_time')) && safe_attribute?('due_time') && self.due_date.is_a?(Time)

      self.due_date = load_localised_time(self.due_date, due_time, user.time_zone)

    end

  # Callback on start and due time

  def add_start_and_due_time

    return if not project.use_datetime_for_issues

    # Not sure if this is a hack or not, but it works :)

    time_zone = User.current.time_zone

    system_time_zone = Time.zone

    if time_zone

      Time.zone = time_zone

    end

    if st=start_time and sd=start_date

      if st['hour'].to_i >= 0 or st['minute'].to_i >= 0

        self.start_date = Time.zone.parse( "#{sd.year}.#{sd.month}.#{sd.day} #{st['hour']}:#{st['minute']}:00" ).utc # Parse in as local but save as UTC

      end

    end

    if dt=due_time and dd=due_date

      if dt['hour'].to_i >= 0 or dt['minute'].to_i >= 0

        self.due_date = Time.zone.parse( "#{dd.year}.#{dd.month}.#{dd.day} #{dt['hour']}:#{dt['minute']}:00").utc # Parse in as local but save as UTC

      end

    end

    # Since we fudged the timezone to get the values parsing in okay, let's reset it to the system timezone.

    Time.zone = system_time_zone

  end

     issues.minimum('start_date').nil? ? nil : issues.minimum('start_date').to_date,

     Issue.fixed_version(shared_versions).minimum('start_date').nil? ? nil : Issue.fixed_version(shared_versions).minimum('start_date').to_date

     issues.maximum('due_date').nil? ? nil : issues.maximum('due_date').to_date,

     Issue.fixed_version(shared_versions).maximum('due_date').nil? ? nil : Issue.fixed_version(shared_versions).maximum('due_date').to_date

    active? && !due_date.nil? && (due_date < DateTime.now)

    'use_datetime_for_issues',

      done_date = start_date.to_date + ((due_date.to_date - start_date.to_date + 1) * completed_percent/100).floor

  <%= f.text_field(:start_date, :value => (@issue.start_date ? localise_date(@issue.start_date).strftime('%Y-%m-%d') : ''), :size => 10, :required => @issue.required_attribute?('start_date')) %>

  <%= f.text_field(:due_date, :value => (@issue.due_date ? localise_date(@issue.due_date).strftime('%Y-%m-%d') : ''), :size => 10, :required => @issue.required_attribute?('due_date')) %>

    rows.right l(:field_start_date), (@project.use_datetime_for_issues ? format_time(@issue.start_date) : format_date(@issue.start_date)), :class => 'start-date'

    rows.right l(:field_due_date), (@project.use_datetime_for_issues ? format_time(@issue.due_date) : format_date(@issue.due_date)), :class => 'due-date'

<p><%= f.check_box :use_datetime_for_issues %></p>

  field_use_datetime_for_issues: Použít u tiketů také čas

  field_use_datetime_for_issues: Use time in tickets too

  field_use_datetime_for_issues: Use time in tickets too

  field_use_datetime_for_issues: Usar hora en prog peticiones

class AddTimeToIssueStartDateAndIssueDueDate < ActiveRecord::Migration

  def self.up

    change_column :issues, :start_date, :datetime

    change_column :issues, :due_date, :datetime

  end

  def self.down

    change_column :issues, :start_date, :date

    change_column :issues, :due_date, :date

  end

end

class AddUseDatetimeForIssuesToProjects < ActiveRecord::Migration

  def self.up

    add_column :projects, :use_datetime_for_issues, :boolean, :default => false

  end

  def self.down

    remove_column :projects, :use_datetime_for_issues

  end

end

        @ending_events_by_days = @events.group_by {|event| (event.due_date.is_a?(Date) || event.due_date.nil? ? event.due_date : event.due_date.to_date) }

        @starting_events_by_days = @events.group_by {|event| (event.start_date.is_a?(Date) || event.start_date.nil?  ? event.start_date : event.start_date.to_date) }

        start_date = start_date.to_date if not start_date.nil?

        end_date = end_date.to_date if not end_date.nil?

        start_date.to_date + (end_date.to_date - start_date.to_date + 1) * (progress / 100.0)

    def localise_date(date)

      return if date.nil?

      zone = User.current.time_zone

      local = zone ? date.in_time_zone(zone) : date

      return local

    end

          start_cwday = from.to_date.cwday

          cwday = date.to_date.cwday

        cwday = date.to_date.cwday

      assert_select 'input[name=?][value]', 'issue[start_date]', 1

    assert_equal DateTime.parse('2010-11-07'), issue.start_date

      assert_equal Date.today, issue.start_date.to_date

    assert_equal DateTime.parse('2012-07-14'), issue.start_date

      assert_equal '2009-12-01 00:00:00 UTC', issue.start_date.to_s, "Start date is incorrect"

      assert_equal '2009-12-31 00:00:00 UTC', issue.due_date.to_s, "Due date is incorrect"