DaylightSavingUtils.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.utils.date;

  23. import java.time.*;
  24. import java.time.format.DateTimeFormatter;
  25. import java.time.zone.ZoneOffsetTransition;
  26. import java.time.zone.ZoneRules;

  28. /**     
  29.  * DaylightSavingUtils
  30.  *
  31.  * @author Poli Andrea (poli@link.it)
  32.  * @author $Author$
  33.  * @version $Rev$, $Date$
  34.  */
  35. public class DaylightSavingUtils {
  36.     
  37.     /**
  38.      * Ora Solare (CET - Central European Time): L'ora solare è il tempo standard utilizzato durante l'inverno. In Europa, è UTC+1, il che significa che è un'ora avanti rispetto al Coordinated Universal Time (UTC). L'ora solare è usata dal tardo autunno all'inizio della primavera, solitamente da fine ottobre a fine marzo.

  40.        Ora Legale (CEST - Central European Summer Time): L'ora legale viene utilizzata durante l'estate per risparmiare energia, spostando le lancette avanti di un'ora. In Europa, è UTC+2, ovvero due ore avanti rispetto a UTC. L'ora legale è in vigore da fine marzo a fine ottobre.

  42.        Passaggio da Ora Legale a Ora Solare: In autunno (solitamente l'ultima domenica di ottobre), l'orologio viene spostato indietro di un'ora alle 03:00 AM CEST, tornando alle 02:00 AM CET (ora solare).
  43.        Passaggio da Ora Solare a Ora Legale: In primavera (solitamente l'ultima domenica di marzo), l'orologio viene spostato avanti di un'ora alle 02:00 AM CET, diventando le 03:00 AM CEST (ora legale).
  44.      */
  45.     
  46.     private DaylightSavingUtils() {}

  48.     // Formato per il parsing delle date con offset
  49.     private static final String OFFSET_FORMAT = "yyyy-MM-dd HH:mm:ssXXX";
  50.     public static String getOffsetFormat() {
  51.         return OFFSET_FORMAT;
  52.     }
  53.     private static final DateTimeFormatter OFFSET_FORMATTER = DateTimeFormatter.ofPattern(OFFSET_FORMAT);
  54.     public static DateTimeFormatter getOffsetFormatter() {
  55.         return OFFSET_FORMATTER;
  56.     }

  58.     // Formato per il parsing delle date senza offset
  59.     private static final String BASIC_FORMAT = "yyyy-MM-dd HH:mm:ss";
  60.     public static String getBasicFormat() {
  61.         return BASIC_FORMAT;
  62.     }
  63.     private static final DateTimeFormatter BASIC_FORMATTER = DateTimeFormatter.ofPattern(BASIC_FORMAT);
  64.     public static DateTimeFormatter getBasicFormatter() {
  65.         return BASIC_FORMATTER;
  66.     }

  68.     // Zona di riferimento, ad esempio Europe/Rome
  69.     /**private static final ZoneId ZONE_ID = ZoneId.of("Europe/Rome");*/
  70.     private static final ZoneId ZONE_ID_DEFAULT = ZoneId.systemDefault();
  71.     public static ZoneId getZoneIdDefault() {
  72.         return ZONE_ID_DEFAULT;
  73.     }
  74.     
  75.     /**
  76.      * Calcola quanti minuti mancano al prossimo cambio di ora legale o solare
  77.      * per una data con offset di fuso orario.
  78.      *
  79.      * @param inputDate La data in formato "yyyy-MM-dd HH:mm:ss+01"
  80.      * @return Minuti mancanti al cambio di ora
  81.      */
  82.     public static long minutesUntilNextTransition(String inputDate) {
  83.         return minutesUntilNextTransition(inputDate, ZONE_ID_DEFAULT);
  84.     }
  85.     public static long minutesUntilNextTransition(String inputDate, ZoneId zoneId) {
  86.         return minutesUntilNextTransition(inputDate, zoneId, null, null);
  87.     }
  88.     public static long minutesUntilNextTransition(String inputDate, String format) {
  89.         return minutesUntilNextTransition(inputDate, ZONE_ID_DEFAULT, format);
  90.     }
  91.     public static long minutesUntilNextTransition(String inputDate, ZoneId zoneId, String format) {
  92.         return minutesUntilNextTransition(inputDate, zoneId, format, null);
  93.     }
  94.     public static long minutesUntilNextTransition(String inputDate, DateTimeFormatter formatter) {
  95.         return minutesUntilNextTransition(inputDate, ZONE_ID_DEFAULT, formatter);
  96.     }
  97.     public static long minutesUntilNextTransition(String inputDate, ZoneId zoneId, DateTimeFormatter formatter) {
  98.         return minutesUntilNextTransition(inputDate, zoneId, null, formatter);
  99.     }
  100.     private static long minutesUntilNextTransition(String inputDate, ZoneId zoneId, String format, DateTimeFormatter formatter) {
  101.         OffsetDateTime offsetDateTime = formatter!=null ? parseOffsetDateTime(inputDate, formatter) : parseOffsetDateTime(inputDate, format);
  102.         ZonedDateTime zonedDateTime = offsetDateTime.atZoneSameInstant(zoneId);

  104.         ZoneRules zoneRules = zoneId.getRules();
  105.         ZoneOffsetTransition nextTransition = zoneRules.nextTransition(zonedDateTime.toInstant());

  107.         if (nextTransition != null) {
  108.             ZonedDateTime transitionDateTime = ZonedDateTime.ofInstant(nextTransition.getDateTimeBefore(), nextTransition.getOffsetBefore(), zoneId);
  109.             return Duration.between(zonedDateTime, transitionDateTime).toMinutes();
  110.         }
  111.         return -1; // Nessuna transizione trovata
  112.     }

  114.     /**
  115.      * Calcola quanti minuti mancano al prossimo cambio di ora legale o solare
  116.      * per una data senza offset di fuso orario.
  117.      *
  118.      * @param inputDate La data in formato "yyyy-MM-dd HH:mm:ss"
  119.      * @return Minuti mancanti al cambio di ora
  120.      */
  121.     public static long minutesUntilNextTransitionWithoutOffset(String inputDate) {
  122.         return minutesUntilNextTransitionWithoutOffset(inputDate, ZONE_ID_DEFAULT);
  123.     }
  124.     public static long minutesUntilNextTransitionWithoutOffset(String inputDate, ZoneId zoneId) {
  125.         return minutesUntilNextTransitionWithoutOffset(inputDate, zoneId, null, null);
  126.     }
  127.     public static long minutesUntilNextTransitionWithoutOffset(String inputDate, String format) {
  128.         return minutesUntilNextTransitionWithoutOffset(inputDate, ZONE_ID_DEFAULT, format);
  129.     }
  130.     public static long minutesUntilNextTransitionWithoutOffset(String inputDate, ZoneId zoneId, String format) {
  131.         return minutesUntilNextTransitionWithoutOffset(inputDate, zoneId, format, null);
  132.     }
  133.     public static long minutesUntilNextTransitionWithoutOffset(String inputDate, DateTimeFormatter formatter) {
  134.         return minutesUntilNextTransitionWithoutOffset(inputDate, ZONE_ID_DEFAULT, formatter);
  135.     }
  136.     public static long minutesUntilNextTransitionWithoutOffset(String inputDate, ZoneId zoneId, DateTimeFormatter formatter) {
  137.         return minutesUntilNextTransitionWithoutOffset(inputDate, zoneId, null, formatter);
  138.     }
  139.     private static long minutesUntilNextTransitionWithoutOffset(String inputDate, ZoneId zoneId, String format, DateTimeFormatter formatter) {
  140.         LocalDateTime localDateTime = formatter!=null ? parseLocalDateTime(inputDate, formatter) : parseLocalDateTime(inputDate, format);
  141.         ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId);

  143.         ZoneRules zoneRules = zoneId.getRules();
  144.         ZoneOffsetTransition nextTransition = zoneRules.nextTransition(zonedDateTime.toInstant());

  146.         if (nextTransition != null) {
  147.             ZonedDateTime transitionDateTime = ZonedDateTime.ofInstant(nextTransition.getDateTimeBefore(), nextTransition.getOffsetBefore(), zoneId);
  148.             return Duration.between(zonedDateTime, transitionDateTime).toMinutes();
  149.         }
  150.         return -1; // Nessuna transizione trovata
  151.     }
  152.     
  153.     
  154.     /**
  155.      * Determina se una certa data si trova in ora legale o ora solare.
  156.      *
  157.      * @param inputDate La data in formato "yyyy-MM-dd HH:mm:ss+01"
  158.      * @return "ora legale" o "ora solare" a seconda della data
  159.      */
  160.     public static TimeType getTimeType(String inputDate) {
  161.         return getTimeType(inputDate, ZONE_ID_DEFAULT);
  162.     }
  163.     public static TimeType getTimeType(String inputDate, ZoneId zoneId) {
  164.         return getTimeType(inputDate, zoneId, null, null);
  165.     }
  166.     public static TimeType getTimeType(String inputDate, String format) {
  167.         return getTimeType(inputDate, ZONE_ID_DEFAULT, format);
  168.     }
  169.     public static TimeType getTimeType(String inputDate, ZoneId zoneId, String format) {
  170.         return getTimeType(inputDate, zoneId, format, null);
  171.     }
  172.     public static TimeType getTimeType(String inputDate, DateTimeFormatter formatter) {
  173.         return getTimeType(inputDate, ZONE_ID_DEFAULT, formatter);
  174.     }
  175.     public static TimeType getTimeType(String inputDate, ZoneId zoneId, DateTimeFormatter formatter) {
  176.         return getTimeType(inputDate, zoneId, null, formatter);
  177.     }
  178.     private static TimeType getTimeType(String inputDate, ZoneId zoneId, String format, DateTimeFormatter formatter) {
  179.         OffsetDateTime offsetDateTime = formatter!=null ? parseOffsetDateTime(inputDate, formatter) : parseOffsetDateTime(inputDate, format);
  180.         ZonedDateTime zonedDateTime = offsetDateTime.atZoneSameInstant(zoneId);

  182.         boolean isDaylightSavings = zonedDateTime.getZone().getRules().isDaylightSavings(zonedDateTime.toInstant());
  183.         return isDaylightSavings ? TimeType.DAYLIGHT_SAVING_TIME : TimeType.STANDARD_TIME;
  184.     }

  186.     /**
  187.      * Converte una data in formato "yyyy-MM-dd HH:mm:ss+01" in un ZonedDateTime
  188.      * per il fuso orario specificato (es. Europe/Rome).
  189.      *
  190.      * @param inputDate La data in formato "yyyy-MM-dd HH:mm:ss+01"
  191.      * @return ZonedDateTime corrispondente
  192.      */
  193.     public static ZonedDateTime convertToZonedDateTime(String inputDate) {
  194.         return convertToZonedDateTime(inputDate, ZONE_ID_DEFAULT);
  195.     }
  196.     public static ZonedDateTime convertToZonedDateTime(String inputDate, ZoneId zoneId) {
  197.         return convertToZonedDateTime(inputDate, zoneId, null, null);
  198.     }
  199.     public static ZonedDateTime convertToZonedDateTime(String inputDate, String format) {
  200.         return convertToZonedDateTime(inputDate, ZONE_ID_DEFAULT, format);
  201.     }
  202.     public static ZonedDateTime convertToZonedDateTime(String inputDate, ZoneId zoneId, String format) {
  203.         return convertToZonedDateTime(inputDate, zoneId, format, null);
  204.     }
  205.     public static ZonedDateTime convertToZonedDateTime(String inputDate, DateTimeFormatter formatter) {
  206.         return convertToZonedDateTime(inputDate, ZONE_ID_DEFAULT, formatter);
  207.     }
  208.     public static ZonedDateTime convertToZonedDateTime(String inputDate, ZoneId zoneId, DateTimeFormatter formatter) {
  209.         return convertToZonedDateTime(inputDate, zoneId, null, formatter);
  210.     }
  211.     private static ZonedDateTime convertToZonedDateTime(String inputDate, ZoneId zoneId, String format, DateTimeFormatter formatter) {
  212.         OffsetDateTime offsetDateTime = formatter!=null ? parseOffsetDateTime(inputDate, formatter) : parseOffsetDateTime(inputDate, format);
  213.         return offsetDateTime.atZoneSameInstant(zoneId);
  214.     }

  216.     
  217.     /**
  218.      * Determina se una data è nel giorno in cui avviene il cambio tra ora legale e ora solare (o viceversa).
  219.      *
  220.      * @param inputDate La data in formato "yyyy-MM-dd HH:mm:ss+01:00"
  221.      * @return true se la data è nel giorno del cambio di ora, false altrimenti
  222.      */
  223.     public static TimeTransitionType getTimeChangePendingToday(String inputDate) {
  224.         return getTimeChangePendingToday(inputDate, ZONE_ID_DEFAULT);
  225.     }
  226.     public static TimeTransitionType getTimeChangePendingToday(String inputDate, ZoneId zoneId) {
  227.         return getTimeChangePendingToday(inputDate, zoneId, null, null);
  228.     }
  229.     public static TimeTransitionType getTimeChangePendingToday(String inputDate, String format) {
  230.         return getTimeChangePendingToday(inputDate, ZONE_ID_DEFAULT, format);
  231.     }
  232.     public static TimeTransitionType getTimeChangePendingToday(String inputDate, ZoneId zoneId, String format) {
  233.         return getTimeChangePendingToday(inputDate, zoneId, format, null);
  234.     }
  235.     public static TimeTransitionType getTimeChangePendingToday(String inputDate, DateTimeFormatter formatter) {
  236.         return getTimeChangePendingToday(inputDate, ZONE_ID_DEFAULT, formatter);
  237.     }
  238.     public static TimeTransitionType getTimeChangePendingToday(String inputDate, ZoneId zoneId, DateTimeFormatter formatter) {
  239.         return getTimeChangePendingToday(inputDate, zoneId, null, formatter);
  240.     }
  241.     private static TimeTransitionType getTimeChangePendingToday(String inputDate, ZoneId zoneId, String format, DateTimeFormatter formatter) {
  242.         // Parse della stringa in OffsetDateTime
  243.         OffsetDateTime dateTime = formatter!=null ? parseOffsetDateTime(inputDate, formatter) : parseOffsetDateTime(inputDate, format);

  245.         // Ottieni il fuso orario dell'ambiente (ad esempio Europe/Rome)
  246.          ZoneRules zoneRules = zoneId.getRules();

  248.         // Ottieni la transizione successiva
  249.         ZoneOffsetTransition nextTransition = zoneRules.nextTransition(dateTime.toInstant());

  251.         if (nextTransition != null) {
  252.             // Ottieni la data e l'ora del giorno della transizione
  253.             LocalDate transitionDate = nextTransition.getDateTimeBefore().toLocalDate();

  255.             // Verifica se la data fornita è nello stesso giorno della transizione
  256.             if( dateTime.toLocalDate().equals(transitionDate) ) {
  257.                  // Ottieni gli offset prima e dopo la transizione
  258.                 ZoneOffset offsetBefore = nextTransition.getOffsetBefore();
  259.                 ZoneOffset offsetAfter = nextTransition.getOffsetAfter();

  261.                 // Determina il tipo di transizione
  262.                 if (offsetBefore.getTotalSeconds() > offsetAfter.getTotalSeconds()) {
  263.                     return TimeTransitionType.FROM_DAYLIGHT_SAVING_TO_STANDARD_TIME;  // Ora legale a ora solare
  264.                 } else {
  265.                     return TimeTransitionType.FROM_STANDARD_TO_DAYLIGHT_SAVING_TIME;  // Ora solare a ora legale
  266.                 }

  268.             }
  269.         }
  270.         
  271.         return null;  // Nessuna transizione trovata
  272.     }
  273.     
  274.     
  275.     /**
  276.      * Determina se una data è nel giorno in cui avviene il cambio tra ora legale e ora solare (o viceversa) per una data senza offset di fuso orario.
  277.      *
  278.      * @param inputDate La data in formato "yyyy-MM-dd HH:mm:ss"
  279.      * @return true se la data è nel giorno del cambio di ora, false altrimenti
  280.      */
  281.     public static TimeTransitionType getTimeChangePendingTodayWithoutOffset(String inputDate) {
  282.         return getTimeChangePendingTodayWithoutOffset(inputDate, ZONE_ID_DEFAULT);
  283.     }
  284.     public static TimeTransitionType getTimeChangePendingTodayWithoutOffset(String inputDate, ZoneId zoneId) {
  285.         return getTimeChangePendingTodayWithoutOffset(inputDate, zoneId, null, null);
  286.     }
  287.     public static TimeTransitionType getTimeChangePendingTodayWithoutOffset(String inputDate, String format) {
  288.         return getTimeChangePendingTodayWithoutOffset(inputDate, ZONE_ID_DEFAULT, format);
  289.     }
  290.     public static TimeTransitionType getTimeChangePendingTodayWithoutOffset(String inputDate, ZoneId zoneId, String format) {
  291.         return getTimeChangePendingTodayWithoutOffset(inputDate, zoneId, format, null);
  292.     }
  293.     public static TimeTransitionType getTimeChangePendingTodayWithoutOffset(String inputDate, DateTimeFormatter formatter) {
  294.         return getTimeChangePendingTodayWithoutOffset(inputDate, ZONE_ID_DEFAULT, formatter);
  295.     }
  296.     public static TimeTransitionType getTimeChangePendingTodayWithoutOffset(String inputDate, ZoneId zoneId, DateTimeFormatter formatter) {
  297.         return getTimeChangePendingTodayWithoutOffset(inputDate, zoneId, null, formatter);
  298.     }
  299.     private static TimeTransitionType getTimeChangePendingTodayWithoutOffset(String inputDate, ZoneId zoneId, String format, DateTimeFormatter formatter) {
  300.         
  301.         LocalDateTime localDateTime = formatter!=null ? parseLocalDateTime(inputDate, formatter) : parseLocalDateTime(inputDate, format);
  302.         ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId);

  304.         ZoneRules zoneRules = zoneId.getRules();
  305.         ZoneOffsetTransition nextTransition = zoneRules.nextTransition(zonedDateTime.toInstant());

  307.         if (nextTransition != null) {
  308.             ZonedDateTime transitionDateTime = ZonedDateTime.ofInstant(nextTransition.getDateTimeBefore(), nextTransition.getOffsetBefore(), zoneId);
  309.             
  310.               // Verifica se la data fornita è nello stesso giorno della transizione
  311.             if( localDateTime.toLocalDate().equals(transitionDateTime.toLocalDate()) ) {
  312.                  // Ottieni gli offset prima e dopo la transizione
  313.                 ZoneOffset offsetBefore = nextTransition.getOffsetBefore();
  314.                 ZoneOffset offsetAfter = nextTransition.getOffsetAfter();

  316.                 // Determina il tipo di transizione
  317.                 if (offsetBefore.getTotalSeconds() > offsetAfter.getTotalSeconds()) {
  318.                     return TimeTransitionType.FROM_DAYLIGHT_SAVING_TO_STANDARD_TIME;  // Ora legale a ora solare
  319.                 } else {
  320.                     return TimeTransitionType.FROM_STANDARD_TO_DAYLIGHT_SAVING_TIME;  // Ora solare a ora legale
  321.                 }

  323.             }
  324.         }
  325.         
  326.         return null;  // Nessuna transizione trovata
  327.     }
  328.     
  329.     
  330.     
  331.     /** Parser */
  332.     
  333.     public static LocalDateTime parseLocalDateTime(String inputDate) {
  334.         return parseLocalDateTime(inputDate, BASIC_FORMATTER);
  335.     }
  336.     public static LocalDateTime parseLocalDateTime(String inputDate, String format) {
  337.         if(format==null) {
  338.             return parseLocalDateTime(inputDate);
  339.         }
  340.         return parseLocalDateTime(inputDate, DateTimeFormatter.ofPattern(format));
  341.     }
  342.     public static LocalDateTime parseLocalDateTime(String inputDate, DateTimeFormatter formatter) {
  343.         if(formatter==null) {
  344.             return parseLocalDateTime(inputDate);
  345.         }
  346.         return LocalDateTime.parse(inputDate, formatter);
  347.     }
  348.     
  349.     public static OffsetDateTime parseOffsetDateTime(String inputDate) {
  350.         return parseOffsetDateTime(inputDate, OFFSET_FORMATTER);
  351.     }
  352.     public static OffsetDateTime parseOffsetDateTime(String inputDate, String format) {
  353.         if(format==null) {
  354.             return parseOffsetDateTime(inputDate);
  355.         }
  356.         return parseOffsetDateTime(inputDate, DateTimeFormatter.ofPattern(format));
  357.     }
  358.     public static OffsetDateTime parseOffsetDateTime(String inputDate, DateTimeFormatter formatter) {
  359.         if(formatter==null) {
  360.             return parseOffsetDateTime(inputDate);
  361.         }
  362.         if (inputDate.matches(".*[+-]\\d{2}$")) {
  363.             inputDate += ":00";
  364.         }
  365.         return OffsetDateTime.parse(inputDate, formatter);
  366.     }
  367. }
Created with JaCoCo 0.8.8.202204050719