Ruby / Rails - Changer le fuseau horaire d'une heure, sans changer la valeur

J'ai un record foo dans la base de données qui a :start_timeet des :timezoneattributs.

Le :start_timeest un temps en UTC -2001-01-01 14:20:00 , par exemple. Le :timezoneest une chaîne - America/New_York, par exemple.

Je souhaite créer un nouvel objet Time avec la valeur de :start_timemais dont le fuseau horaire est spécifié par:timezone . Je ne veux pas charger :start_timepuis convertir en :timezone, car Rails sera intelligent et mettra à jour l'heure UTC pour être cohérente avec ce fuseau horaire.

Actuellement,

t = foo.start_time
=> 2000-01-01 14:20:00 UTC
t.zone
=> "UTC"
t.in_time_zone("America/New_York")
=> Sat, 01 Jan 2000 09:20:00 EST -05:00

Au lieu de cela, je veux voir

=> Sat, 01 Jan 2000 14:20:00 EST -05:00

c'est à dire. Je veux faire:

t
=> 2000-01-01 14:20:00 UTC
t.zone = "America/New_York"
=> "America/New_York"
t
=> 2000-01-01 14:20:00 EST

On dirait que vous voulez quelque chose du genre

ActiveSupport::TimeZone.new('America/New_York').local_to_utc(t)

Cela dit convertir cette heure locale (en utilisant la zone) en utc. Si vous avez Time.zonedéfini, vous pouvez bien sûr

Time.zone.local_to_utc(t)

Cela n'utilisera pas le fuseau horaire associé à t - cela suppose qu'il est local par rapport au fuseau horaire à partir duquel vous effectuez la conversion.

Les transitions DST constituent un cas de pointe à éviter: l'heure locale que vous spécifiez peut ne pas exister ou être ambiguë.

Je viens de faire face au même problème et voici ce que je vais faire:

t = t.asctime.in_time_zone("America/New_York")

Voici la documentation sur asctime

Si vous utilisez Rails, voici une autre méthode dans le sens de la réponse d'Eric Walsh:

def set_in_timezone(time, zone)
  Time.use_zone(zone) { time.to_datetime.change(offset: Time.zone.now.strftime("%z")) }
end

Vous devez ajouter le décalage horaire à votre temps après l'avoir converti.

Le moyen le plus simple de procéder est:

t = Foo.start_time.in_time_zone("America/New_York")
t -= t.utc_offset

Je ne sais pas pourquoi vous voudriez faire cela, bien qu'il soit probablement préférable de travailler avec les temps tels qu'ils sont construits. Je suppose que des informations sur les raisons pour lesquelles vous devez changer l'heure et les fuseaux horaires seraient utiles.

En fait, je pense que vous devez soustraire le décalage après l'avoir converti, comme dans:

1.9.3p194 :042 > utc_time = Time.now.utc
=> 2013-05-29 16:37:36 UTC
1.9.3p194 :043 > local_time = utc_time.in_time_zone('America/New_York')
 => Wed, 29 May 2013 12:37:36 EDT -04:00
1.9.3p194 :044 > desired_time = local_time-local_time.utc_offset
 => Wed, 29 May 2013 16:37:36 EDT -04:00 

Cela dépend de l'endroit où vous allez utiliser ce temps.

Quand ton temps est un attribut

Si l'heure est utilisée comme attribut, vous pouvez utiliser la même gemme date_time_attribute :

class Task
  include DateTimeAttribute
  date_time_attribute :due_at
end

task = Task.new
task.due_at_time_zone = 'Moscow'
task.due_at                      # => Mon, 03 Feb 2013 22:00:00 MSK +04:00
task.due_at_time_zone = 'London'
task.due_at                      # => Mon, 03 Feb 2013 22:00:00 GMT +00:00

Lorsque vous définissez une variable distincte

Utilisez le même gemme date_time_attribute :

my_date_time = DateTimeAttribute::Container.new(Time.zone.now)
my_date_time.date_time           # => 2001-02-03 22:00:00 KRAT +0700
my_date_time.time_zone = 'Moscow'
my_date_time.date_time           # => 2001-02-03 22:00:00 MSK +0400

def relative_time_in_time_zone(time, zone)
   DateTime.parse(time.strftime("%d %b %Y %H:%M:%S #{time.in_time_zone(zone).formatted_offset}"))
end

Petite fonction rapide que j'ai inventée pour résoudre le travail. Si quelqu'un a un moyen plus efficace de faire cela, veuillez le poster!

t.change(zone: 'America/New_York')

La prémisse de l'OP est incorrecte: "Je ne veux pas charger le: start_time puis le convertir en: timezone, car Rails sera intelligent et mettra à jour l'heure UTC pour être cohérente avec ce fuseau horaire." Ce n'est pas nécessairement vrai, comme le montre la réponse fournie ici.

J'ai créé quelques méthodes d'aide dont l'une fait la même chose que celle demandée par l'auteur original du message sur Ruby / Rails - Changer le fuseau horaire d'une heure, sans changer la valeur .

J'ai également documenté quelques particularités que j'ai observées et ces aides contiennent également des méthodes pour ignorer complètement les économies automatiques de lumière du jour applicables lors des conversions de temps qui ne sont pas disponibles prêtes à l'emploi dans le cadre de Rails:

  def utc_offset_of_given_time(time, ignore_dst: false)
    # Correcting the utc_offset below
    utc_offset = time.utc_offset

    if !!ignore_dst && time.dst?
      utc_offset_ignoring_dst = utc_offset - 3600 # 3600 seconds = 1 hour
      utc_offset = utc_offset_ignoring_dst
    end

    utc_offset
  end

  def utc_offset_of_given_time_ignoring_dst(time)
    utc_offset_of_given_time(time, ignore_dst: true)
  end

  def change_offset_in_given_time_to_given_utc_offset(time, utc_offset)
    formatted_utc_offset = ActiveSupport::TimeZone.seconds_to_utc_offset(utc_offset, false)

    # change method accepts :offset option only on DateTime instances.
    # and also offset option works only when given formatted utc_offset
    # like -0500. If giving it number of seconds like -18000 it is not
    # taken into account. This is not mentioned clearly in the documentation
    # , though.
    # Hence the conversion to DateTime instance first using to_datetime.
    datetime_with_changed_offset = time.to_datetime.change(offset: formatted_utc_offset)

    Time.parse(datetime_with_changed_offset.to_s)
  end

  def ignore_dst_in_given_time(time)
    return time unless time.dst?

    utc_offset = time.utc_offset

    if utc_offset < 0
      dst_ignored_time = time - 1.hour
    elsif utc_offset > 0
      dst_ignored_time = time + 1.hour
    end

    utc_offset_ignoring_dst = utc_offset_of_given_time_ignoring_dst(time)

    dst_ignored_time_with_corrected_offset =
      change_offset_in_given_time_to_given_utc_offset(dst_ignored_time, utc_offset_ignoring_dst)

    # A special case for time in timezones observing DST and which are
    # ahead of UTC. For e.g. Tehran city whose timezone is Iran Standard Time
    # and which observes DST and which is UTC +03:30. But when DST is active
    # it becomes UTC +04:30. Thus when a IRDT (Iran Daylight Saving Time)
    # is given to this method say '05-04-2016 4:00pm' then this will convert
    # it to '05-04-2016 5:00pm' and update its offset to +0330 which is incorrect.
    # The updated UTC offset is correct but the hour should retain as 4.
    if utc_offset > 0
      dst_ignored_time_with_corrected_offset -= 1.hour
    end

    dst_ignored_time_with_corrected_offset
  end

Exemples qui peuvent être essayés sur la console rails ou un script ruby ​​après avoir encapsulé les méthodes ci-dessus dans une classe ou un module:

dd1 = '05-04-2016 4:00pm'
dd2 = '07-11-2016 4:00pm'

utc_zone = ActiveSupport::TimeZone['UTC']
est_zone = ActiveSupport::TimeZone['Eastern Time (US & Canada)']
tehran_zone = ActiveSupport::TimeZone['Tehran']

utc_dd1 = utc_zone.parse(dd1)
est_dd1 = est_zone.parse(dd1)
tehran_dd1 = tehran_zone.parse(dd1)

utc_dd1.dst?
est_dd1.dst?
tehran_dd1.dst?

ignore_dst = true
utc_to_est_time = utc_dd1.in_time_zone(est_zone.name)
if utc_to_est_time.dst? && !!ignore_dst
  utc_to_est_time = ignore_dst_in_given_time(utc_to_est_time)
end

puts utc_to_est_time

J'espère que cela t'aides.

Voici une autre version qui a mieux fonctionné pour moi que les réponses actuelles:

now = Time.now
# => 2020-04-15 12:07:10 +0200
now.strftime("%F %T.%N").in_time_zone("Europe/London")
# => Wed, 15 Apr 2020 12:07:10 BST +01:00

Il reporte les nanosecondes en utilisant "% N". Si vous désirez une autre précision, consultez cette référence strftime .

J'ai également passé beaucoup de temps à me débattre avec TimeZones, et après avoir bricolé Ruby 1.9.3, j'ai réalisé que vous n'aviez pas besoin de convertir en un symbole de fuseau horaire nommé avant de convertir:

my_time = Time.now
west_coast_time = my_time.in_time_zone(-8) # Pacific Standard Time
east_coast_time = my_time.in_time_zone(-5) # Eastern Standard Time

Ce que cela implique, c'est que vous pouvez vous concentrer sur l'obtention de la configuration de l'heure appropriée en premier dans la région que vous voulez, la façon dont vous y penseriez (au moins dans ma tête, je la partitionne de cette façon), puis convertissez à la fin de la zone vous souhaitez vérifier votre logique métier avec.

Cela fonctionne également pour Ruby 2.3.1.