DateUtils.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.text.ParseException;
  24. import java.text.SimpleDateFormat;
  25. import java.time.Instant;
  26. import java.time.LocalDate;
  27. import java.time.LocalDateTime;
  28. import java.time.LocalTime;
  29. import java.time.ZoneId;
  30. import java.time.ZonedDateTime;
  31. import java.time.format.DateTimeFormatter;
  32. import java.util.Calendar;
  33. import java.util.Date;
  34. import java.util.HashMap;
  35. import java.util.Map;
  36. import java.util.regex.Matcher;
  37. import java.util.regex.Pattern;

  39. import org.joda.time.DateTime;
  40. import org.joda.time.DateTimeZone;
  41. import org.openspcoop2.utils.UtilsException;

  43. /**     
  44.  * DateUtils
  45.  *
  46.  * @author Poli Andrea (poli@link.it)
  47.  * @author $Author$
  48.  * @version $Rev$, $Date$
  49.  */
  50. public class DateUtils {


  53.     public static Date convertToLeftInterval(Date date, UnitaTemporale unitaTemporale) {
  54.         
  55.         Calendar calendar = null;
  56.         try{
  57.             calendar = DateManager.getCalendar();
  58.         }catch(Exception e){
  59.             calendar = Calendar.getInstance();
  60.         }
  61.         calendar.setTime(date);
  62.         switch (unitaTemporale) {
  63.         case SECONDI:
  64.             calendar.set(Calendar.MILLISECOND, 0);
  65.             break;
  66.         case MINUTI:        
  67.             calendar.set(Calendar.SECOND, 0);
  68.             calendar.set(Calendar.MILLISECOND, 0);
  69.             break;
  70.         case ORARIO:        
  71.             calendar.set(Calendar.MINUTE, 0);
  72.             calendar.set(Calendar.SECOND, 0);
  73.             calendar.set(Calendar.MILLISECOND, 0);
  74.             break;
  75.         case GIORNALIERO:   
  76.             calendar.set(Calendar.HOUR_OF_DAY, 0);
  77.             calendar.set(Calendar.MINUTE, 0);
  78.             calendar.set(Calendar.SECOND, 0);
  79.             calendar.set(Calendar.MILLISECOND, 0);
  80.             break;
  81.         case SETTIMANALE:
  82.             while(Calendar.MONDAY!=calendar.get(Calendar.DAY_OF_WEEK)){
  83.                 calendar.add(Calendar.DAY_OF_WEEK, -1);
  84.             }
  85.             calendar.set(Calendar.HOUR_OF_DAY, 0);
  86.             calendar.set(Calendar.MINUTE, 0);
  87.             calendar.set(Calendar.SECOND, 0);
  88.             calendar.set(Calendar.MILLISECOND, 0);
  89.             break;
  90.         case MENSILE:
  91.             calendar.set(Calendar.DAY_OF_MONTH, 1);
  92.             calendar.set(Calendar.HOUR_OF_DAY, 0);
  93.             calendar.set(Calendar.MINUTE, 0);
  94.             calendar.set(Calendar.SECOND, 0);
  95.             calendar.set(Calendar.MILLISECOND, 0);
  96.         }
  97.         
  98.         return calendar.getTime();
  99.     }
  100.     
  101.     public static Date convertToRightInterval(Date date, UnitaTemporale unitaTemporale) {
  102.                 
  103.         Calendar calendar = null;
  104.         try{
  105.             calendar = DateManager.getCalendar();
  106.         }catch(Exception e){
  107.             calendar = Calendar.getInstance();
  108.         }
  109.         calendar.setTime(date);
  110.         switch (unitaTemporale) {
  111.         case SECONDI:
  112.             calendar.set(Calendar.MILLISECOND, 999);
  113.             break;
  114.         case MINUTI:        
  115.             calendar.set(Calendar.SECOND, 59);
  116.             calendar.set(Calendar.MILLISECOND, 999);
  117.             break;
  118.         case ORARIO:        
  119.             calendar.set(Calendar.MINUTE, 59);
  120.             calendar.set(Calendar.SECOND, 59);
  121.             calendar.set(Calendar.MILLISECOND, 999);
  122.             break;
  123.         case GIORNALIERO:   
  124.             calendar.set(Calendar.HOUR_OF_DAY, 23);
  125.             calendar.set(Calendar.MINUTE, 59);
  126.             calendar.set(Calendar.SECOND, 59);
  127.             calendar.set(Calendar.MILLISECOND, 999);
  128.             break;
  129.         case SETTIMANALE:
  130.             while(Calendar.SUNDAY!=calendar.get(Calendar.DAY_OF_WEEK)){
  131.                 calendar.add(Calendar.DAY_OF_WEEK, 1);
  132.             }
  133.             calendar.set(Calendar.HOUR_OF_DAY, 23);
  134.             calendar.set(Calendar.MINUTE, 59);
  135.             calendar.set(Calendar.SECOND, 59);
  136.             calendar.set(Calendar.MILLISECOND, 999);
  137.             break;
  138.         case MENSILE:
  139.             calendar.set(Calendar.HOUR_OF_DAY, 23);
  140.             calendar.set(Calendar.MINUTE, 59);
  141.             calendar.set(Calendar.SECOND, 59);
  142.             calendar.set(Calendar.MILLISECOND, 999);
  143.             // prelevo ultimo giorno del mese impostato nell'attuale data
  144.             int lastDayActualMonth = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
  145.             calendar.set(Calendar.DAY_OF_MONTH, lastDayActualMonth);
  146.             break;
  147.         }
  148.         
  149.         return calendar.getTime();
  150.     }
  151.         
  152.     public static Date incrementDate(Date date, UnitaTemporale unitaTemporale, int increment) {
  153.         
  154.         if(increment==0){
  155.             return date;
  156.         }
  157.         
  158.         Calendar calendar = null;
  159.         try{
  160.             calendar = DateManager.getCalendar();
  161.         }catch(Exception e){
  162.             calendar = Calendar.getInstance();
  163.         }
  164.         calendar.setTime(date);
  165.         switch (unitaTemporale) {
  166.         case SECONDI:
  167.             calendar.add(Calendar.SECOND, increment);
  168.             break;
  169.         case MINUTI:        
  170.             calendar.add(Calendar.MINUTE, increment);
  171.             break;
  172.         case ORARIO:        
  173.             calendar.add(Calendar.HOUR_OF_DAY, increment);
  174.             break;
  175.         case GIORNALIERO:   
  176.             calendar.add(Calendar.DAY_OF_YEAR, increment);
  177.             break;
  178.         case SETTIMANALE:
  179.             calendar.add(Calendar.DAY_OF_YEAR, (increment*7));
  180.             break;
  181.         case MENSILE:
  182.             calendar.add(Calendar.MONTH, increment);
  183.             // prelevo ultimo giorno del mese impostato nell'attuale data
  184.             int lastDayActualMonth = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
  185.             calendar.set(Calendar.DAY_OF_MONTH, lastDayActualMonth);
  186.             break;
  187.         }
  188.         
  189.         return calendar.getTime();
  190.     }
  191.     
  192.     public static Date incrementDate1Millisecond(Date date){
  193.         Calendar calendar = null;
  194.         try{
  195.             calendar = DateManager.getCalendar();
  196.         }catch(Exception e){
  197.             calendar = Calendar.getInstance();
  198.         }
  199.         calendar.setTime(date);
  200.         calendar.add(Calendar.MILLISECOND, 1);
  201.         return calendar.getTime();
  202.     }
  203.     
  204.     public Date decrementDate1Millisecond(Date date){
  205.         Calendar calendar = null;
  206.         try{
  207.             calendar = DateManager.getCalendar();
  208.         }catch(Exception e){
  209.             calendar = Calendar.getInstance();
  210.         }
  211.         calendar.setTime(date);
  212.         calendar.add(Calendar.MILLISECOND, -1);
  213.         return calendar.getTime();
  214.     }
  215.     
  216.     public static Date incredementDate1MsIf999(Date date){
  217.         
  218.         // se la data รจ impostata all'ultimo millisecondo (999), viene portato al successivo
  219.         
  220.         Calendar calendar = null;
  221.         try{
  222.             calendar = DateManager.getCalendar();
  223.         }catch(Exception e){
  224.             calendar = Calendar.getInstance();
  225.         }
  226.         calendar.setTime(date);
  227.         
  228.         int ms = calendar.get(Calendar.MILLISECOND);
  229.         if(ms>=999) {
  230.             calendar.add(Calendar.MILLISECOND, 1);
  231.             return calendar.getTime();
  232.         }
  233.         else {
  234.             return date;
  235.         }
  236.         
  237.     }
  238.     
  239.     /**
  240.      * https://datatracker.ietf.org/doc/html/rfc3339#section-5.6
  241.      * 
  242.      * Secondo RFC 3339 Sezione 5.6, i caratteri T e Z sono case-sensitive, e quindi devono essere rispettivamente in maiuscolo. Inoltre, l'uso dello spazio al posto del carattere T per separare la data e l'ora non รจ permesso in una rappresentazione conforme a RFC 3339.
  243.      * 
  244.      * Uso di "T" e "Z" maiuscole e minuscole
  245.      * Per ABNF e ISO 8601: L'RFC chiarisce che sia l'ABNF (usato per definire la sintassi) sia la specifica ISO 8601 permettono l'uso delle lettere minuscole "t" e "z" come alternative alle maiuscole "T" e "Z".
  246.      * Comunque sia le applicazioni che generano timestamp conformi a RFC 3339 dovrebbero preferibilmente utilizzare le lettere maiuscole "T" e "Z" per garantire maggiore compatibilitร  e aderenza alle convenzioni comuni.
  247.      * 
  248.      * L'ultima nota evidenzia che ISO 8601 consente di usare uno spazio al posto della "T" come separatore tra la data e l'ora, ma RFC 3339 non prevede questa opzione.
  249.      * Quindi per rispettare rigorosamente l'RFC 3339, deve essere usate la "T" (o eventualmente "t").
  250.      * Tuttavia, in altri contesti o per migliorare la leggibilitร , potrebbe essere accettabile usare uno spazio, ma ciรฒ รจ fuori dall'ambito strettamente RFC 3339.
  251.      */
  252.     private static boolean dateTimeAllowLowerCaseTZ = false;
  253.     private static boolean dateTimeAllowSpaceSeparator = false;
  254.     public static boolean isDateTimeAllowLowerCaseTZ() {
  255.         return dateTimeAllowLowerCaseTZ;
  256.     }
  257.     public static void setDateTimeAllowLowerCaseTZ(boolean dateTimeAllowLowerCaseTZ) {
  258.         DateUtils.dateTimeAllowLowerCaseTZ = dateTimeAllowLowerCaseTZ;
  259.     }
  260.     public static boolean isDateTimeAllowSpaceSeparator() {
  261.         return dateTimeAllowSpaceSeparator;
  262.     }
  263.     public static void setDateTimeAllowSpaceSeparator(boolean dateTimeAllowSpaceSeparator) {
  264.         DateUtils.dateTimeAllowSpaceSeparator = dateTimeAllowSpaceSeparator;
  265.     }
  266.     private static String buildDateTimeSeparatorPattern(boolean dateTimeAllowLowerCase, boolean dateTimeAllowSpaceSeparator) {
  267.         StringBuilder sb = new StringBuilder();
  268.         sb.append("T");
  269.         if(dateTimeAllowLowerCase) {
  270.             sb.append("t"); 
  271.         }
  272.         if(dateTimeAllowSpaceSeparator) {
  273.             sb.append(" "); 
  274.         }
  275.         return sb.toString();
  276.     }
  277.     private static String buildTimeZonePattern(boolean dateTimeAllowLowerCase) {
  278.         StringBuilder sb = new StringBuilder();
  279.         sb.append("Z");
  280.         if(dateTimeAllowLowerCase) {
  281.             sb.append("z"); 
  282.         }
  283.         return sb.toString();
  284.     }
  285.     
  286.     private static final String RFC3339_56_ERROR = "' has wrong format (see RFC 3339, section 5.6): ";
  287.     private static final String UNCORRECT_FORMAT = "Uncorrect format";
  288.     
  289.     private static final String DATETIME_PATTERN_SEPARATOR = "tT ";
  290.     private static final String DATETIME_PATTERN_TIMEZONE = "zZ";
  291.     private static final String DATETIME_PATTERN = "^\\d{4}-(?:0[0-9]{1}|1[0-2]{1})-(0?[1-9]|[12][0-9]|3[01])["+DATETIME_PATTERN_SEPARATOR+"]\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(["+DATETIME_PATTERN_TIMEZONE+"]|[+-]\\d{2}:\\d{2})$";
  292.     public static void validateDateTimeAsRFC3339Sec56(String dateTime) throws UtilsException {
  293.         validateDateTimeAsRFC3339Sec56(dateTime, DateUtils.dateTimeAllowLowerCaseTZ, DateUtils.dateTimeAllowSpaceSeparator);
  294.     }
  295.     public static void validateDateTimeAsRFC3339Sec56(String dateTime, boolean allowLowerCaseTZ, boolean allowSpaceSeparator) throws UtilsException {
  296.         // RFC 3339, section 5.6
  297.         // es 2017-07-21T17:32:28Z
  298.         String fullDate = null;
  299.         String fullTime = null;
  300.         try {
  301.             // date-time = full-date "T" full-time
  302.             String separator = null;
  303.             if(!dateTime.contains("T")) {
  304.                 if(allowLowerCaseTZ && dateTime.contains("t")) {
  305.                     separator="t";
  306.                 }
  307.                 else if(allowSpaceSeparator && dateTime.contains(" ")) {
  308.                     separator=" ";
  309.                 }
  310.                 else {
  311.                     throw new UtilsException("Expected 'T' separator");
  312.                 }
  313.             }
  314.             else {
  315.                 separator="T";
  316.             }
  317.             String [] split = dateTime.split(separator);
  318.             if(split==null || split.length!=2) {
  319.                 throw new UtilsException("Expected 'full-date T full-time' format");
  320.             }
  321.             
  322.             // check regexp
  323.             String dateTimePattern = DATETIME_PATTERN.replace(DATETIME_PATTERN_SEPARATOR, buildDateTimeSeparatorPattern(allowLowerCaseTZ, allowSpaceSeparator));
  324.             dateTimePattern = dateTimePattern.replace(DATETIME_PATTERN_TIMEZONE, buildTimeZonePattern(allowLowerCaseTZ));
  325.             if(!isMatchEngine(dateTime, dateTimePattern)) {
  326.                 throw new UtilsException(UNCORRECT_FORMAT);
  327.             }
  328.             
  329.             // full-date = date-fullyear "-" date-month "-" date-mday
  330.             // date-fullyear   = 4DIGIT
  331.             // date-month      = 2DIGIT  ; 01-12
  332.             // date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on month/year
  333.             fullDate = split[0];
  334.             fullTime = split[1];
  335.         }catch(Exception e){
  336.             throw new UtilsException("Found dateTime '"+dateTime+RFC3339_56_ERROR+e.getMessage(),e);
  337.         }
  338.         
  339.         validateDateAsRFC3339Sec56(fullDate);
  340.         validateTimeAsRFC3339Sec56(fullTime);
  341.     }
  342.     
  343.     private static final String FULL_DATE_FORMAT = "yyyy-MM-dd";
  344.     private static final String DATE_PATTERN = "^\\d{4}-(?:0[0-9]{1}|1[0-2]{1})-(0?[1-9]|[12][0-9]|3[01])$";
  345.     public static void validateDateAsRFC3339Sec56(String fullDate) throws UtilsException {
  346.         // RFC 3339, section 5.6
  347.         // es 2017-07-21
  348.         try {
  349.             // full-date = date-fullyear "-" date-month "-" date-mday
  350.             // date-fullyear   = 4DIGIT
  351.             // date-month      = 2DIGIT  ; 01-12
  352.             // date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on month/year
  353.             if(fullDate==null || "".equals(fullDate)) {
  354.                 throw new UtilsException("undefined");
  355.             }
  356.             // check regexp
  357.             if(!isMatchEngine(fullDate, DATE_PATTERN)) {
  358.                 throw new UtilsException(UNCORRECT_FORMAT);
  359.             }
  360.             validateDateAsRFC3339Sec56WithSimpleDateFormat(fullDate);
  361.         }catch(Exception e){
  362.             throw new UtilsException("Found date '"+fullDate+RFC3339_56_ERROR+e.getMessage(),e);
  363.         }
  364.     }
  365.     private static void validateDateAsRFC3339Sec56WithSimpleDateFormat(String fullDate) throws UtilsException {
  366.         try {
  367.             SimpleDateFormat sdf = new SimpleDateFormat(FULL_DATE_FORMAT);
  368.             Date d = sdf.parse(fullDate);
  369.             d.toString();
  370.         }catch(Exception e) {
  371.             throw new UtilsException("uncorrect format: "+e.getMessage(),e);
  372.         }
  373.     }
  374.     
  375.     private static final String FULL_TIME_FORMAT_SECONDS = "HH:mm:ss.SSS";
  376.     private static final String FULL_TIME_FORMAT_WITHOUT_SECONDS = "HH:mm:ss";
  377.     private static final String FULL_TIME_FORMAT_OFFSET = "HH:mm";
  378.     private static final String TIME_PATTERN = "^\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(["+DATETIME_PATTERN_TIMEZONE+"]|[+-]\\d{2}:\\d{2})$";
  379.     public static void validateTimeAsRFC3339Sec56(String fullTime) throws UtilsException {
  380.         validateTimeAsRFC3339Sec56(fullTime, DateUtils.dateTimeAllowLowerCaseTZ);
  381.     }
  382.     public static void validateTimeAsRFC3339Sec56(String fullTime, boolean allowLowerCaseTZ) throws UtilsException {
  383.         // RFC 3339, section 5.6
  384.         // es 17:32:28Z
  385.         try {
  386.             // full-time = partial-time time-offset
  387.             // partial-time    = time-hour ":" time-minute ":" time-second [time-secfrac]
  388.             // time-hour       = 2DIGIT  ; 00-23
  389.             // time-minute     = 2DIGIT  ; 00-59
  390.             // time-second     = 2DIGIT  ; 00-58, 00-59, 00-60 based on leap second
  391.             // time-secfrac    = "." 1*DIGIT
  392.             // time-offset     = "Z" / time-numoffset
  393.             // time-numoffset  = ("+" / "-") time-hour ":" time-minute
  394.             if(fullTime==null || "".equals(fullTime)) {
  395.                 throw new UtilsException("undefined");
  396.             }
  397.             if(fullTime.length()<9) {
  398.                 throw new UtilsException("too short");
  399.             }
  400.             // check regexp
  401.             String timePattern = TIME_PATTERN.replace(DATETIME_PATTERN_TIMEZONE, buildTimeZonePattern(allowLowerCaseTZ));
  402.             if(!isMatchEngine(fullTime, timePattern)) {
  403.                 throw new UtilsException(UNCORRECT_FORMAT);
  404.             }
  405.             String partialTime = validateTimeAsRFC3339Sec56PartialTime(fullTime);
  406.             if(partialTime==null || "".equals(partialTime)) {
  407.                 throw new UtilsException("undefined partial time");
  408.             }
  409.             validateTimeAsRFC3339Sec56WithSimpleDateFormaPartialTime(partialTime);
  410.             
  411.         }catch(Exception e){
  412.             throw new UtilsException("Found time '"+fullTime+RFC3339_56_ERROR+e.getMessage(),e);
  413.         }
  414.     }
  415.     private static String validateTimeAsRFC3339Sec56PartialTime(String fullTime) throws UtilsException {
  416.         String partialTime = null;
  417.         if(fullTime.endsWith("Z") || fullTime.endsWith("z")) {
  418.             partialTime = fullTime.substring(0, fullTime.length()-1);
  419.         }
  420.         else {
  421.             if(!fullTime.contains("+") && !fullTime.contains("-")) {
  422.                 throw new UtilsException("expected '(\"+\" / \"-\") or \"Z\" time-offset character");
  423.             }
  424.             String offset = null;
  425.             String [] splitFullTime = null;
  426.             if(fullTime.contains("+")) {
  427.                 splitFullTime = fullTime.split("\\+");
  428.             }
  429.             else {
  430.                 splitFullTime = fullTime.split("-");
  431.             }
  432.             if(splitFullTime==null || splitFullTime.length!=2) {
  433.                 throw new UtilsException("expected partial-time time-offset");
  434.             }
  435.             partialTime = splitFullTime[0];
  436.             offset = splitFullTime[1];
  437.             
  438.             if(offset==null || "".equals(fullTime)) {
  439.                 throw new UtilsException("undefined offset time");
  440.             }
  441.             validateTimeAsRFC3339Sec56WithSimpleDateFormatOffset(offset);
  442.         }
  443.         return partialTime;
  444.     }
  445.     private static void validateTimeAsRFC3339Sec56WithSimpleDateFormatOffset(String offset) throws UtilsException {
  446.         try {
  447.             SimpleDateFormat sdf = new SimpleDateFormat(FULL_TIME_FORMAT_OFFSET);
  448.             Date d = sdf.parse(offset);
  449.             d.toString();
  450.         }catch(Exception e) {
  451.             throw new UtilsException("uncorrect offset format: "+e.getMessage(),e);
  452.         }
  453.     }
  454.     private static void validateTimeAsRFC3339Sec56WithSimpleDateFormaPartialTime(String partialTime) throws UtilsException {
  455.         try {
  456.             SimpleDateFormat sdf = null;
  457.             if(partialTime.contains(".")) {
  458.                 sdf = new SimpleDateFormat(FULL_TIME_FORMAT_SECONDS);
  459.             }
  460.             else {
  461.                 sdf = new SimpleDateFormat(FULL_TIME_FORMAT_WITHOUT_SECONDS);
  462.             }
  463.             Date d = sdf.parse(partialTime);
  464.             d.toString();
  465.         }catch(Exception e) {
  466.             throw new UtilsException("uncorrect offset format: "+e.getMessage(),e);
  467.         }
  468.     }
  469.     
  470.     private static boolean isMatchEngine(String contenuto, String pattern) throws UtilsException{
  471.         
  472.         if( (pattern == null) || (pattern.length() == 0))
  473.             throw new UtilsException("Pattern di ricerca non fornito");
  474.         if( (contenuto == null) || (contenuto.length() == 0))
  475.             throw new UtilsException("Contenuto su cui effettuare una ricerca non fornita");
  476.         
  477.         try{
  478.             Pattern p = Pattern.compile(pattern);
  479.             Matcher matcher = p.matcher(contenuto);
  480.             return matcher.matches();
  481.         }catch(Exception e){
  482.             throw new UtilsException("isMatch contenuto["+contenuto+"] pattern["+pattern+"] error: "+e.getMessage(),e);
  483.         }
  484.     }
  485.     
  486.     
  487.     
  488.     

  490.     /** FORMAT Simple Date Format */
  491.     
  492.     private static DateEngineType DEFAULT_DATA_ENGINE_TYPE = DateEngineType.JAVA_TIME;
  493.     public static DateEngineType getDEFAULT_DATA_ENGINE_TYPE() {
  494.         return DEFAULT_DATA_ENGINE_TYPE;
  495.     }
  496.     public static void setDEFAULT_DATA_ENGINE_TYPE(DateEngineType dEFAULT_DATA_ENGINE_TYPE) {
  497.         DEFAULT_DATA_ENGINE_TYPE = dEFAULT_DATA_ENGINE_TYPE;
  498.     }

  500.     public static final String SIMPLE_DATE_FORMAT_MS = "yyyy-MM-dd_HH:mm:ss.SSS";
  501.     public static SimpleDateFormat getSimpleDateFormatMs() {
  502.         return getDefaultDateTimeFormatterMs();
  503.     }
  504.     public static SimpleDateFormat getOldSimpleDateFormatMs() {
  505.         return new SimpleDateFormat (SIMPLE_DATE_FORMAT_MS); // SimpleDateFormat non e' thread-safe
  506.     }
  507.     public static DateTimeFormatter getDateTimeFormatterMs() {
  508.         return DateUtils.getDateTimeFormatter(SIMPLE_DATE_FORMAT_MS);
  509.     }
  510.     public static org.joda.time.format.DateTimeFormatter getJodaDateTimeFormatterMs() {
  511.         return DateUtils.getJodaDateTimeFormatter(SIMPLE_DATE_FORMAT_MS);
  512.     }
  513.     public static DateTimeFormatterWrapper getDateTimeFormatterMs(DateEngineType type) {
  514.         return new DateTimeFormatterWrapper(type.toDateTimeType(), SIMPLE_DATE_FORMAT_MS, false);
  515.     }
  516.     public static DateTimeFormatterWrapper getDefaultDateTimeFormatterMs() {
  517.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateTimeType(), SIMPLE_DATE_FORMAT_MS, false);
  518.     }
  519.     
  520.     public static final String SIMPLE_DATE_FORMAT_MS_ISO_8601_TZ = "yyyy-MM-dd_HH:mm:ss.SSSX";
  521.     public static SimpleDateFormat getSimpleDateFormatMs_ISO_8601_TZ() {
  522.         return getDefaultDateTimeFormatterMs_ISO_8601_TZ();
  523.     }
  524.     public static SimpleDateFormat getOldSimpleDateFormatMs_ISO_8601_TZ() {
  525.         SimpleDateFormat sdf = new SimpleDateFormat (SIMPLE_DATE_FORMAT_MS_ISO_8601_TZ); // SimpleDateFormat non e' thread-safe
  526.         sdf.setCalendar(Calendar.getInstance());
  527.         return sdf;
  528.     }
  529.     public static DateTimeFormatter getDateTimeFormatterMs_ISO_8601_TZ() {
  530.         return DateUtils.getDateTimeFormatter(SIMPLE_DATE_FORMAT_MS_ISO_8601_TZ);
  531.     }
  532.     public static org.joda.time.format.DateTimeFormatter getJodaDateTimeFormatterMs_ISO_8601_TZ() {
  533.         return DateUtils.getJodaDateTimeFormatter(SIMPLE_DATE_FORMAT_MS_ISO_8601_TZ);
  534.     }
  535.     public static DateTimeFormatterWrapper getDateTimeFormatterMs_ISO_8601_TZ(DateEngineType type) {
  536.         return new DateTimeFormatterWrapper(type.toDateTimeType(), SIMPLE_DATE_FORMAT_MS_ISO_8601_TZ, true);
  537.     }
  538.     public static DateTimeFormatterWrapper getDefaultDateTimeFormatterMs_ISO_8601_TZ() {
  539.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateTimeType(), SIMPLE_DATE_FORMAT_MS_ISO_8601_TZ, true);
  540.     }
  541.     
  542.     public static final String SIMPLE_DATE_FORMAT_SECOND = "yyyy-MM-dd_HH:mm:ss";
  543.     public static SimpleDateFormat getSimpleDateFormatSecond() {
  544.         return getDefaultDateTimeFormatterSecond();
  545.     }
  546.     public static SimpleDateFormat getOldSimpleDateFormatSecond() {
  547.         return new SimpleDateFormat (SIMPLE_DATE_FORMAT_SECOND); // SimpleDateFormat non e' thread-safe
  548.     }
  549.     public static DateTimeFormatter getDateTimeFormatterSecond() {
  550.         return DateUtils.getDateTimeFormatter(SIMPLE_DATE_FORMAT_SECOND);
  551.     }
  552.     public static org.joda.time.format.DateTimeFormatter getJodaDateTimeFormatterSecond() {
  553.         return DateUtils.getJodaDateTimeFormatter(SIMPLE_DATE_FORMAT_SECOND);
  554.     }
  555.     public static DateTimeFormatterWrapper getDateTimeFormatterSecond(DateEngineType type) {
  556.         return new DateTimeFormatterWrapper(type.toDateTimeType(), SIMPLE_DATE_FORMAT_SECOND, false);
  557.     }
  558.     public static DateTimeFormatterWrapper getDefaultDateTimeFormatterSecond() {
  559.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateTimeType(), SIMPLE_DATE_FORMAT_SECOND, false);
  560.     }
  561.     
  562.     public static final String SIMPLE_DATE_FORMAT_SECOND_ISO_8601_TZ = "yyyy-MM-dd_HH:mm:ssX";
  563.     public static SimpleDateFormat getSimpleDateFormatSecond_ISO_8601_TZ() {
  564.         return getDefaultDateTimeFormatterSecond_ISO_8601_TZ();
  565.     }
  566.     public static SimpleDateFormat getOldSimpleDateFormatSecond_ISO_8601_TZ() {
  567.         SimpleDateFormat sdf =  new SimpleDateFormat (SIMPLE_DATE_FORMAT_SECOND_ISO_8601_TZ); // SimpleDateFormat non e' thread-safe
  568.         sdf.setCalendar(Calendar.getInstance());
  569.         return sdf;
  570.     }
  571.     public static DateTimeFormatter getDateTimeFormatterSecond_ISO_8601_TZ() {
  572.         return DateUtils.getDateTimeFormatter(SIMPLE_DATE_FORMAT_SECOND_ISO_8601_TZ);
  573.     }
  574.     public static org.joda.time.format.DateTimeFormatter getJodaDateTimeFormatterSecond_ISO_8601_TZ() {
  575.         return DateUtils.getJodaDateTimeFormatter(SIMPLE_DATE_FORMAT_SECOND_ISO_8601_TZ);
  576.     }
  577.     public static DateTimeFormatterWrapper getDateTimeFormatterSecond_ISO_8601_TZ(DateEngineType type) {
  578.         return new DateTimeFormatterWrapper(type.toDateTimeType(), SIMPLE_DATE_FORMAT_SECOND_ISO_8601_TZ, true);
  579.     }
  580.     public static DateTimeFormatterWrapper getDefaultDateTimeFormatterSecond_ISO_8601_TZ() {
  581.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateTimeType(), SIMPLE_DATE_FORMAT_SECOND_ISO_8601_TZ, true);
  582.     }
  583.     
  584.     public static final String SIMPLE_DATE_FORMAT_MINUTE = "yyyy-MM-dd_HH:mm";
  585.     public static SimpleDateFormat getSimpleDateFormatMinute() {
  586.         return getDefaultDateTimeFormatterMinute();
  587.     }
  588.     public static SimpleDateFormat getOldSimpleDateFormatMinute() {
  589.         return new SimpleDateFormat (SIMPLE_DATE_FORMAT_MINUTE); // SimpleDateFormat non e' thread-safe
  590.     }
  591.     public static DateTimeFormatter getDateTimeFormatterMinute() {
  592.         return DateUtils.getDateTimeFormatter(SIMPLE_DATE_FORMAT_MINUTE);
  593.     }
  594.     public static org.joda.time.format.DateTimeFormatter getJodaDateTimeFormatterMinute() {
  595.         return DateUtils.getJodaDateTimeFormatter(SIMPLE_DATE_FORMAT_MINUTE);
  596.     }
  597.     public static DateTimeFormatterWrapper getDateTimeFormatterMinute(DateEngineType type) {
  598.         return new DateTimeFormatterWrapper(type.toDateTimeType(), SIMPLE_DATE_FORMAT_MINUTE, false);
  599.     }
  600.     public static DateTimeFormatterWrapper getDefaultDateTimeFormatterMinute() {
  601.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateTimeType(), SIMPLE_DATE_FORMAT_MINUTE, false);
  602.     }
  603.     
  604.     public static final String SIMPLE_DATE_FORMAT_MINUTE_ISO_8601_TZ = "yyyy-MM-dd_HH:mmX";
  605.     public static SimpleDateFormat getSimpleDateFormatMinute_ISO_8601_TZ() {
  606.         return getDefaultDateTimeFormatterMinute_ISO_8601_TZ();
  607.     }
  608.     public static SimpleDateFormat getOldSimpleDateFormatMinute_ISO_8601_TZ() {
  609.         SimpleDateFormat sdf =  new SimpleDateFormat (SIMPLE_DATE_FORMAT_MINUTE_ISO_8601_TZ); // SimpleDateFormat non e' thread-safe
  610.         sdf.setCalendar(Calendar.getInstance());
  611.         return sdf;
  612.     }
  613.     public static DateTimeFormatter getDateTimeFormatterMinute_ISO_8601_TZ() {
  614.         return DateUtils.getDateTimeFormatter(SIMPLE_DATE_FORMAT_MINUTE_ISO_8601_TZ);
  615.     }
  616.     public static org.joda.time.format.DateTimeFormatter getJodaDateTimeFormatterMinute_ISO_8601_TZ() {
  617.         return DateUtils.getJodaDateTimeFormatter(SIMPLE_DATE_FORMAT_MINUTE_ISO_8601_TZ);
  618.     }
  619.     public static DateTimeFormatterWrapper getDateTimeFormatterMinute_ISO_8601_TZ(DateEngineType type) {
  620.         return new DateTimeFormatterWrapper(type.toDateTimeType(), SIMPLE_DATE_FORMAT_MINUTE_ISO_8601_TZ, true);
  621.     }
  622.     public static DateTimeFormatterWrapper getDefaultDateTimeFormatterMinute_ISO_8601_TZ() {
  623.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateTimeType(), SIMPLE_DATE_FORMAT_MINUTE_ISO_8601_TZ, true);
  624.     }
  625.     
  626.     public static final String SIMPLE_DATE_FORMAT_HOUR = "yyyy-MM-dd_HH";
  627.     public static SimpleDateFormat getSimpleDateFormatHour() {
  628.         return getDefaultDateTimeFormatterHour();
  629.     }
  630.     public static SimpleDateFormat getOldSimpleDateFormatHour() {
  631.         return new SimpleDateFormat (SIMPLE_DATE_FORMAT_HOUR); // SimpleDateFormat non e' thread-safe
  632.     }
  633.     public static DateTimeFormatter getDateTimeFormatterHour() {
  634.         return DateUtils.getDateTimeFormatter(SIMPLE_DATE_FORMAT_HOUR);
  635.     }
  636.     public static org.joda.time.format.DateTimeFormatter getJodaDateTimeFormatterHour() {
  637.         return DateUtils.getJodaDateTimeFormatter(SIMPLE_DATE_FORMAT_HOUR);
  638.     }
  639.     public static DateTimeFormatterWrapper getDateTimeFormatterHour(DateEngineType type) {
  640.         return new DateTimeFormatterWrapper(type.toDateTimeType(), SIMPLE_DATE_FORMAT_HOUR, false);
  641.     }
  642.     public static DateTimeFormatterWrapper getDefaultDateTimeFormatterHour() {
  643.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateTimeType(), SIMPLE_DATE_FORMAT_HOUR, false);
  644.     }
  645.     
  646.     public static final String SIMPLE_DATE_FORMAT_HOUR_ISO_8601_TZ = "yyyy-MM-dd_HHX";
  647.     public static SimpleDateFormat getSimpleDateFormatHour_ISO_8601_TZ() {
  648.         return getDefaultDateTimeFormatterHour_ISO_8601_TZ();
  649.     }
  650.     public static SimpleDateFormat getOldSimpleDateFormatHour_ISO_8601_TZ() {
  651.         SimpleDateFormat sdf =  new SimpleDateFormat (SIMPLE_DATE_FORMAT_HOUR_ISO_8601_TZ); // SimpleDateFormat non e' thread-safe
  652.         sdf.setCalendar(Calendar.getInstance());
  653.         return sdf;
  654.     }
  655.     public static DateTimeFormatter getDateTimeFormatterHour_ISO_8601_TZ() {
  656.         return DateUtils.getDateTimeFormatter(SIMPLE_DATE_FORMAT_HOUR_ISO_8601_TZ);
  657.     }
  658.     public static org.joda.time.format.DateTimeFormatter getJodaDateTimeFormatterHour_ISO_8601_TZ() {
  659.         return DateUtils.getJodaDateTimeFormatter(SIMPLE_DATE_FORMAT_HOUR_ISO_8601_TZ);
  660.     }
  661.     public static DateTimeFormatterWrapper getDateTimeFormatterHour_ISO_8601_TZ(DateEngineType type) {
  662.         return new DateTimeFormatterWrapper(type.toDateTimeType(), SIMPLE_DATE_FORMAT_HOUR_ISO_8601_TZ, true);
  663.     }
  664.     public static DateTimeFormatterWrapper getDefaultDateTimeFormatterHour_ISO_8601_TZ() {
  665.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateTimeType(), SIMPLE_DATE_FORMAT_HOUR_ISO_8601_TZ, true);
  666.     }
  667.     
  668.     public static final String SIMPLE_DATE_FORMAT_DAY = "yyyy-MM-dd";
  669.     public static SimpleDateFormat getSimpleDateFormatDay() {
  670.         return getDefaultDateTimeFormatterDay();
  671.     }
  672.     public static SimpleDateFormat getOldSimpleDateFormatDay() {
  673.         return new SimpleDateFormat (SIMPLE_DATE_FORMAT_DAY); // SimpleDateFormat non e' thread-safe
  674.     }
  675.     public static DateTimeFormatter getDateTimeFormatterDay() {
  676.         return DateUtils.getDateTimeFormatter(SIMPLE_DATE_FORMAT_DAY);
  677.     }
  678.     public static org.joda.time.format.DateTimeFormatter getJodaDateTimeFormatterDay() {
  679.         return DateUtils.getJodaDateTimeFormatter(SIMPLE_DATE_FORMAT_DAY);
  680.     }
  681.     public static DateTimeFormatterWrapper getDateTimeFormatterDay(DateEngineType type) {
  682.         return new DateTimeFormatterWrapper(type.toDateType(), SIMPLE_DATE_FORMAT_DAY, false);
  683.     }
  684.     public static DateTimeFormatterWrapper getDefaultDateTimeFormatterDay() {
  685.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateType(), SIMPLE_DATE_FORMAT_DAY, false);
  686.     }
  687.     
  688.     public static final String SIMPLE_DATE_FORMAT_DAY_ISO_8601_TZ = "yyyy-MM-ddX";
  689.     public static SimpleDateFormat getSimpleDateFormatDay_ISO_8601_TZ() {
  690.         return getDefaultDateTimeFormatterDay_ISO_8601_TZ();
  691.     }
  692.     public static SimpleDateFormat getOldSimpleDateFormatDay_ISO_8601_TZ() {
  693.         SimpleDateFormat sdf = new SimpleDateFormat (SIMPLE_DATE_FORMAT_DAY_ISO_8601_TZ); // SimpleDateFormat non e' thread-safe
  694.         sdf.setCalendar(Calendar.getInstance());
  695.         return sdf;
  696.     }
  697.     public static DateTimeFormatter getDateTimeFormatterDay_ISO_8601_TZ() {
  698.         return DateUtils.getDateTimeFormatter(SIMPLE_DATE_FORMAT_DAY_ISO_8601_TZ);
  699.     }
  700.     public static org.joda.time.format.DateTimeFormatter getJodaDateTimeFormatterDay_ISO_8601_TZ() {
  701.         return DateUtils.getJodaDateTimeFormatter(SIMPLE_DATE_FORMAT_DAY_ISO_8601_TZ);
  702.     }
  703.     public static DateTimeFormatterWrapper getDateTimeFormatterDay_ISO_8601_TZ(DateEngineType type) {
  704.         return new DateTimeFormatterWrapper(type.toDateType(), SIMPLE_DATE_FORMAT_DAY_ISO_8601_TZ, true);
  705.     }
  706.     public static DateTimeFormatterWrapper getDefaultDateTimeFormatterDay_ISO_8601_TZ() {
  707.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateType(), SIMPLE_DATE_FORMAT_DAY_ISO_8601_TZ, true);
  708.     }

  710.     public static SimpleDateFormat getSimpleDateFormat(String format) {
  711.         return getDefaultDateTimeFormatter(format);
  712.     }
  713.     public static SimpleDateFormat getOldSimpleDateFormat(String format) {
  714.         return new SimpleDateFormat (format); // SimpleDateFormat non e' thread-safe
  715.     }
  716.     public static DateTimeFormatterWrapper getDateTimeFormatter(DateEngineType type, String format) {
  717.         return new DateTimeFormatterWrapper(type.toDateTimeType(), format, false);
  718.     }
  719.     public static DateTimeFormatterWrapper getDefaultDateTimeFormatter(String format) {
  720.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateTimeType(), format, false);
  721.     }
  722.     public static DateTimeFormatterWrapper getDateFormatter(DateEngineType type, String format) {
  723.         return new DateTimeFormatterWrapper(type.toDateType(), format, false);
  724.     }
  725.     public static DateTimeFormatterWrapper getDefaultDateFormatter(String format) {
  726.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateType(), format, false);
  727.     }
  728.     public static DateTimeFormatterWrapper getTimeFormatter(DateEngineType type, String format) {
  729.         return new DateTimeFormatterWrapper(type.toTimeType(), format, false);
  730.     }
  731.     public static DateTimeFormatterWrapper getDefaultTimeFormatter(String format) {
  732.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toTimeType(), format, false);
  733.     }
  734.     
  735.     public static SimpleDateFormat getSimpleDateFormat_ISO_8601_TZ(String format) {
  736.         return getDefaultDateTimeFormatter_ISO_8601_TZ(format);
  737.     }
  738.     public static SimpleDateFormat getOldSimpleDateFormat_ISO_8601_TZ(String format) {
  739.         SimpleDateFormat sdf = new SimpleDateFormat (format); // SimpleDateFormat non e' thread-safe
  740.         sdf.setCalendar(Calendar.getInstance());
  741.         return sdf;
  742.     }
  743.     public static DateTimeFormatterWrapper getDateTimeFormatter_ISO_8601_TZ(DateEngineType type, String format) {
  744.         return new DateTimeFormatterWrapper(type.toDateTimeType(), format, true);
  745.     }
  746.     public static DateTimeFormatterWrapper getDefaultDateTimeFormatter_ISO_8601_TZ(String format) {
  747.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateTimeType(), format, true);
  748.     }
  749.     public static DateTimeFormatterWrapper getDateFormatter_ISO_8601_TZ(DateEngineType type, String format) {
  750.         return new DateTimeFormatterWrapper(type.toDateType(), format, true);
  751.     }
  752.     public static DateTimeFormatterWrapper getDefaultDateFormatter_ISO_8601_TZ(String format) {
  753.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toDateType(), format, true);
  754.     }
  755.     public static DateTimeFormatterWrapper getTimeFormatter_ISO_8601_TZ(DateEngineType type, String format) {
  756.         return new DateTimeFormatterWrapper(type.toTimeType(), format, true);
  757.     }
  758.     public static DateTimeFormatterWrapper getDefaultTimeFormatter_ISO_8601_TZ(String format) {
  759.         return new DateTimeFormatterWrapper(DEFAULT_DATA_ENGINE_TYPE.toTimeType(), format, true);
  760.     }
  761.     
  762.     
  763.     
  764.     
  765.     
  766.     /** Simple Date Format che supporta tutti i formati rfc3339 */
  767.     
  768.     public static Date parseDate(String dateParam) throws ParseException {
  769.         return parseDateRFC3339_sec5_6(dateParam);
  770.     } 
  771.     public static Date parseDateRFC3339_sec5_6(String dateParam) throws ParseException {
  772.         String date = dateParam;
  773.         
  774.         // https://tools.ietf.org/html/rfc3339
  775.         boolean withTimeZone = false;
  776.         if(date.length()>SIMPLE_DATE_FORMAT_SECOND.length()) {
  777.             // prendo la parte dopo l'ora, almeno non confondo il '-' del giorno con il '-' dell'offset
  778.             String check = date.substring(SIMPLE_DATE_FORMAT_SECOND.length());
  779.             withTimeZone = check.endsWith("Z") || check.contains("+") || check.contains("-");
  780.         }
  781.                         
  782.         if(date.contains("T")) {
  783.             date = date.replace("T", "_");
  784.             
  785.             if(date.contains(".")) {
  786.                 if(withTimeZone) {
  787.                     return getSimpleDateFormatMs_ISO_8601_TZ().parse(date);
  788.                 }
  789.                 else {
  790.                     return getSimpleDateFormatMs().parse(date);
  791.                 }
  792.             }
  793.             else {
  794.                 if(date.contains(":")) {
  795.                     String [] split = date.split(":");
  796.                     if(split.length>1) {
  797.                         if(withTimeZone) {
  798.                             return getSimpleDateFormatSecond_ISO_8601_TZ().parse(date);
  799.                         }
  800.                         else {
  801.                             return getSimpleDateFormatSecond().parse(date);
  802.                         }
  803.                     }
  804.                     else {
  805.                         if(withTimeZone) {
  806.                             return getSimpleDateFormatMinute_ISO_8601_TZ().parse(date);
  807.                         }
  808.                         else {
  809.                             return getSimpleDateFormatMinute().parse(date);
  810.                         }
  811.                     }
  812.                 }
  813.                 else {
  814.                     if(withTimeZone) {
  815.                         return getSimpleDateFormatHour_ISO_8601_TZ().parse(date);
  816.                     }
  817.                     else {
  818.                         return getSimpleDateFormatHour().parse(date);
  819.                     }
  820.                 }
  821.             }
  822.         }
  823.         else {
  824.             if(withTimeZone) {
  825.                 return getSimpleDateFormatDay_ISO_8601_TZ().parse(date);
  826.             }
  827.             else {
  828.                 return getSimpleDateFormatDay().parse(date);
  829.             }
  830.         }
  831.     }
  832.     
  833.     
  834.     
  835.     /** java.time Parse */
  836.     
  837.     public static LocalDateTime parseToLocalDateTime(String format, String source) {
  838.         // bug fix: Text '20200131105154584' could not be parsed at index 0
  839.         if("yyyyMMddHHmmssSSS".equals(format)) {
  840.             String sCorrect = source;
  841.             if(sCorrect.length()>4) {
  842.                 sCorrect = source.substring(0, 4) + " " + source.substring(4, source.length());
  843.                 return LocalDateTime.parse(sCorrect, DateUtils.getDateTimeFormatter("yyyy MMddHHmmssSSS"));
  844.             }
  845.         }
  846.         return LocalDateTime.parse(source, DateUtils.getDateTimeFormatter(format));
  847.     }
  848.     
  849.     public static LocalDate parseToLocalDate(String format, String source) {
  850.         return LocalDate.parse(source, DateUtils.getDateTimeFormatter(format));
  851.     }
  852.     
  853.     public static LocalTime parseToLocalTime(String format, String source) {
  854.         return LocalTime.parse(source, DateUtils.getDateTimeFormatter(format));
  855.     }
  856.     
  857.     
  858.     /** java.time DateTimeFormatter */
  859.     
  860.     private static Map<String, DateTimeFormatter> mapFormatToDateTimeFormatter = new HashMap<String, DateTimeFormatter>();
  861.     private static synchronized void initDateTimeFormatter(String format) {
  862.         if(mapFormatToDateTimeFormatter.containsKey(format)==false) {
  863.             mapFormatToDateTimeFormatter.put(format, DateTimeFormatter.ofPattern(format));
  864.         }
  865.     }
  866.     public static DateTimeFormatter getDateTimeFormatter(String format) {
  867.         if(mapFormatToDateTimeFormatter.containsKey(format)==false) {
  868.             initDateTimeFormatter(format);
  869.         }
  870.         return mapFormatToDateTimeFormatter.get(format);
  871.     }
  872.     
  873.     
  874.     /** java.time Converter */
  875.     
  876.     private static ZoneId zoneId = ZoneId.systemDefault();
  877.     
  878.     /** java.time Converter (LocalDate) */
  879.     
  880.     public static LocalDate convertToLocalDateViaInstant(Date dateToConvert) {
  881.         return convertToLocalDateViaInstant(dateToConvert, DateUtils.zoneId);
  882.     }
  883.     public static LocalDate convertToLocalDateViaInstant(Date dateToConvert, ZoneId zoneIdParam) {
  884.         return dateToConvert.toInstant()
  885.           .atZone(zoneIdParam)
  886.           .toLocalDate();
  887.     }
  888.     
  889.     public static LocalDate convertToLocalDateViaMilisecond(Date dateToConvert) {
  890.         return convertToLocalDateViaMilisecond(dateToConvert, DateUtils.zoneId);
  891.     }
  892.     public static LocalDate convertToLocalDateViaMilisecond(Date dateToConvert, ZoneId zoneIdParam) {
  893.         return Instant.ofEpochMilli(dateToConvert.getTime())
  894.           .atZone(zoneIdParam)
  895.           .toLocalDate();
  896.     }
  897.     
  898.     public static Date convertToDateViaSqlDate(LocalDate dateToConvert) {
  899.         return java.sql.Date.valueOf(dateToConvert);
  900.     }
  901.     
  902.     public static Date convertToDateViaInstant(LocalDate dateToConvert) {
  903.         return convertToDateViaInstant(dateToConvert, DateUtils.zoneId); 
  904.     }
  905.     public static Date convertToDateViaInstant(LocalDate dateToConvert, ZoneId zoneIdParam) {
  906.         return java.util.Date.from(dateToConvert.atStartOfDay()
  907.           .atZone(zoneIdParam)
  908.           .toInstant());
  909.     }
  910.     
  911.     
  912.     /** java.time Converter (LocalTime) */
  913.     
  914.     public static LocalTime convertToLocalTimeViaInstant(Date dateToConvert) {
  915.         return convertToLocalTimeViaInstant(dateToConvert, DateUtils.zoneId);
  916.     }
  917.     public static LocalTime convertToLocalTimeViaInstant(Date dateToConvert, ZoneId zoneIdParam) {
  918.         return dateToConvert.toInstant()
  919.           .atZone(zoneIdParam)
  920.           .toLocalTime();
  921.     }
  922.     
  923.     public static LocalTime convertToLocalTimeViaMilisecond(Date dateToConvert) {
  924.         return convertToLocalTimeViaMilisecond(dateToConvert, DateUtils.zoneId);
  925.     }
  926.     public static LocalTime convertToLocalTimeViaMilisecond(Date dateToConvert, ZoneId zoneIdParam) {
  927.         return Instant.ofEpochMilli(dateToConvert.getTime())
  928.           .atZone(zoneIdParam)
  929.           .toLocalTime();
  930.     }
  931.     
  932.     public static Date convertToDateViaInstant(LocalTime dateToConvert) {
  933.         return convertToDateViaInstant(dateToConvert, DateUtils.zoneId); 
  934.     }
  935.     public static Date convertToDateViaInstant(LocalTime dateToConvert, ZoneId zoneIdParam) {
  936.         return java.util.Date.from(dateToConvert.atDate(LocalDate.now())
  937.           .atZone(zoneIdParam)
  938.           .toInstant());
  939.     }
  940.     
  941.     
  942.     /** java.time Converter (LocalDateTime) */
  943.     
  944.     public static ZonedDateTime convertToZonedDateTimeViaInstant(Date dateToConvert) {
  945.         return convertToZonedDateTimeViaInstant(dateToConvert, DateUtils.zoneId);
  946.     }
  947.     public static ZonedDateTime convertToZonedDateTimeViaInstant(Date dateToConvert, ZoneId zoneIdParam) {
  948.         return dateToConvert.toInstant()
  949.           .atZone(zoneIdParam);
  950.     }
  951.     
  952.     public static LocalDateTime convertToLocalDateTimeViaInstant(Date dateToConvert) {
  953.         return convertToLocalDateTimeViaInstant(dateToConvert, DateUtils.zoneId);
  954.     }
  955.     public static LocalDateTime convertToLocalDateTimeViaInstant(Date dateToConvert, ZoneId zoneIdParam) {
  956.         return convertToZonedDateTimeViaInstant(dateToConvert, zoneIdParam)
  957.           .toLocalDateTime();
  958.     }
  959.     
  960.     public static ZonedDateTime convertToZonedDateTimeViaMilisecond(Date dateToConvert) {
  961.         return convertToZonedDateTimeViaMilisecond(dateToConvert, DateUtils.zoneId);
  962.     }
  963.     public static ZonedDateTime convertToZonedDateTimeViaMilisecond(Date dateToConvert, ZoneId zoneIdParam) {
  964.         return Instant.ofEpochMilli(dateToConvert.getTime())
  965.           .atZone(zoneIdParam);
  966.     }
  967.     
  968.     public static LocalDateTime convertToLocalDateTimeViaMilisecond(Date dateToConvert) {
  969.         return convertToLocalDateTimeViaMilisecond(dateToConvert, DateUtils.zoneId);
  970.     }
  971.     public static LocalDateTime convertToLocalDateTimeViaMilisecond(Date dateToConvert, ZoneId zoneIdParam) {
  972.         return convertToZonedDateTimeViaMilisecond(dateToConvert, zoneIdParam)
  973.           .toLocalDateTime();
  974.     }
  975.     
  976.     public static LocalDateTime convertToLocalDateTimeViaSqlTimestamp(Date dateToConvert) {
  977.         return new java.sql.Timestamp(dateToConvert.getTime()).toLocalDateTime();
  978.     }

  980.     public static Date convertToDateViaSqlTimestamp(LocalDateTime dateToConvert) {
  981.         return java.sql.Timestamp.valueOf(dateToConvert);
  982.     }
  983.     
  984.     public static Date convertToDateViaInstant(LocalDateTime dateToConvert) {
  985.         return convertToDateViaInstant(dateToConvert, DateUtils.zoneId);
  986.     }
  987.     public static Date convertToDateViaInstant(LocalDateTime dateToConvert, ZoneId zoneIdParam) {
  988.         return java.util.Date
  989.           .from(dateToConvert.atZone(zoneIdParam)
  990.           .toInstant());
  991.     }
  992.     
  993.     public static Date convertToDateViaInstant(ZonedDateTime dateToConvert) {
  994.         return convertToDateViaInstant(dateToConvert, DateUtils.zoneId);
  995.     }
  996.     public static Date convertToDateViaInstant(ZonedDateTime dateToConvert, ZoneId zoneIdParam) {
  997.         return java.util.Date
  998.           .from(dateToConvert
  999.           .toInstant());
  1000.     }
  1001.     
  1002.     
  1003.     
  1004.     
  1005.     /** joda.time Parse */
  1006.     
  1007.     public static org.joda.time.DateTime parseToJodaDateTime(String format, String source) {
  1008.         return DateUtils.getJodaDateTimeFormatter(format).parseDateTime(source);
  1009.     }
  1010.     
  1011.     public static org.joda.time.LocalDateTime parseToJodaLocalDateTime(String format, String source) {
  1012.         return parseToJodaDateTime(format, source).toLocalDateTime();
  1013.     }
  1014.     
  1015.     public static org.joda.time.LocalDate parseToJodaLocalDate(String format, String source) {
  1016.         return parseToJodaDateTime(format, source).toLocalDate();
  1017.     }
  1018.     
  1019.     public static org.joda.time.LocalTime parseToJodaLocalTime(String format, String source) {
  1020.         return parseToJodaDateTime(format, source).toLocalTime();
  1021.     }
  1022.     
  1023.     
  1024.     /** joda.time DateTimeFormatter */
  1025.     
  1026.     private static Map<String, org.joda.time.format.DateTimeFormatter> mapFormatToJodaDateTimeFormatter = new HashMap<String, org.joda.time.format.DateTimeFormatter>();
  1027.     private static String normalizeTimeZoneFormatForJoda(String formato) {
  1028.         return formato.contains("X") ? formato.replaceAll("X", "Z") : formato;
  1029.     }
  1030.     private static synchronized void initJodaDateTimeFormatter(String format) {
  1031.         if(mapFormatToJodaDateTimeFormatter.containsKey(format)==false) {
  1032.             mapFormatToJodaDateTimeFormatter.put(format, org.joda.time.format.DateTimeFormat.forPattern(normalizeTimeZoneFormatForJoda(format)));
  1033.         }
  1034.     }
  1035.     public static org.joda.time.format.DateTimeFormatter getJodaDateTimeFormatter(String format) {
  1036.         if(mapFormatToJodaDateTimeFormatter.containsKey(format)==false) {
  1037.             initJodaDateTimeFormatter(format);
  1038.         }
  1039.         return mapFormatToJodaDateTimeFormatter.get(format);
  1040.     }
  1041.     
  1042.     
  1043.     
  1044.     /** joda.time Converter */
  1045.     
  1046.     private static DateTimeZone dtz = DateTimeZone.getDefault();
  1047.     
  1048.     public static org.joda.time.LocalDate convertToJodaLocalDate(Date dateToConvert) {
  1049.         return convertToJodaLocalDate(dateToConvert, DateUtils.dtz);
  1050.     }
  1051.     public static org.joda.time.LocalDate convertToJodaLocalDate(Date dateToConvert, DateTimeZone dtzParam) {
  1052.         return new org.joda.time.LocalDate(dateToConvert.getTime(), dtzParam);
  1053.     }
  1054.     
  1055.     public static org.joda.time.LocalTime convertToJodaLocalTime(Date dateToConvert) {
  1056.         return convertToJodaLocalTime(dateToConvert, DateUtils.dtz);
  1057.     }
  1058.     public static org.joda.time.LocalTime convertToJodaLocalTime(Date dateToConvert, DateTimeZone dtzParam) {
  1059.         return new org.joda.time.LocalTime(dateToConvert.getTime(), dtzParam);
  1060.     }
  1061.     
  1062.     public static org.joda.time.LocalDateTime convertToJodaLocalDateTime(Date dateToConvert) {
  1063.         return convertToJodaLocalDateTime(dateToConvert, DateUtils.dtz);
  1064.     }
  1065.     public static org.joda.time.LocalDateTime convertToJodaLocalDateTime(Date dateToConvert, DateTimeZone dtzParam) {
  1066.         return new org.joda.time.LocalDateTime(dateToConvert.getTime(), dtzParam);
  1067.     }
  1068.     
  1069.     public static DateTime convertToJodaDateTime(Date dateToConvert) {
  1070.         return convertToJodaDateTime(dateToConvert, DateUtils.dtz);
  1071.     }
  1072.     public static DateTime convertToJodaDateTime(Date dateToConvert, DateTimeZone dtzParam) {
  1073.         return new DateTime(dateToConvert.getTime(), dtzParam);
  1074.     }
  1075.     
  1076.     public static Date convertToDate(org.joda.time.LocalDate dateToConvert) {
  1077.         return dateToConvert.toDate();
  1078.     }
  1079.     public static Date convertToDate(org.joda.time.LocalTime dateToConvert) {
  1080.         return dateToConvert.toDateTimeToday().toDate();
  1081.     }
  1082.     public static Date convertToDate(org.joda.time.LocalDateTime dateToConvert) {
  1083.         return dateToConvert.toDate();
  1084.     }
  1085.     public static Date convertToDate(org.joda.time.DateTime dateToConvert) {
  1086.         return dateToConvert.toDate();
  1087.     }
  1088.     
  1089. }
Created with JaCoCo 0.8.8.202204050719