1 /***********************************************************************
2  * Copyright (c) 2013-2024 Commonwealth Computer Research, Inc.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Apache License, Version 2.0
5  * which accompanies this distribution and is available at
6  * http://www.opensource.org/licenses/apache2.0.php.
7  ***********************************************************************/
8 
9 package org.locationtech.geomesa.utils.text
10 
11 import org.locationtech.geomesa.utils.date.DateUtils.toInstant
12 
13 import java.time._
14 import java.time.format.{DateTimeFormatter, DateTimeFormatterBuilder}
15 import java.time.temporal.{ChronoField, TemporalAccessor, TemporalQuery}
16 import java.util.{Date, Locale}
17 
18 object DateParsing {
19 
20   private val format =
21     new DateTimeFormatterBuilder()
22       .parseCaseInsensitive()
23       .append(DateTimeFormatter.ISO_LOCAL_DATE)
24       .parseLenient()
25       .optionalStart()
26       .appendLiteral('T')
27       .appendValue(ChronoField.HOUR_OF_DAY, 2)
28       .appendLiteral(':')
29       .appendValue(ChronoField.MINUTE_OF_HOUR, 2)
30       .optionalStart()
31       .appendLiteral(':')
32       .appendValue(ChronoField.SECOND_OF_MINUTE, 2)
33       .optionalStart()
34       .appendFraction(ChronoField.MILLI_OF_SECOND, 3, 3, true)
35       .optionalEnd()
36       .optionalEnd()
37       .optionalEnd()
38       .optionalStart()
39       .appendOffsetId()
40       .toFormatter(Locale.US)
41       .withZone(ZoneOffset.UTC)
42 
43   val Epoch: ZonedDateTime = ZonedDateTime.ofInstant(Instant.EPOCH, ZoneOffset.UTC)
44 
45   object TemporalQueries {
46     val ZonedQuery: TemporalQuery[ZonedDateTime] = new TemporalQuery[ZonedDateTime] {
47       override def queryFrom(temporal: TemporalAccessor): ZonedDateTime = ZonedDateTime.from(temporal)
48     }
49     val LocalQuery: TemporalQuery[LocalDateTime] = new TemporalQuery[LocalDateTime] {
50       override def queryFrom(temporal: TemporalAccessor): LocalDateTime = LocalDateTime.from(temporal)
51     }
52     val LocalDateQuery: TemporalQuery[LocalDate] = new TemporalQuery[LocalDate] {
53       override def queryFrom(temporal: TemporalAccessor): LocalDate = LocalDate.from(temporal)
54     }
55     val YearMonthQuery: TemporalQuery[YearMonth] = new TemporalQuery[YearMonth] {
56       override def queryFrom(temporal: TemporalAccessor): YearMonth = YearMonth.from(temporal)
57     }
58     val YearQuery: TemporalQuery[Year] = new TemporalQuery[Year] {
59       override def queryFrom(temporal: TemporalAccessor): Year = Year.from(temporal)
60     }
61   }
62 
63   /**
64     * Parses a date string, with optional time and zone
65     *
66     * @param value date string
67     * @param format date formatter, default ISO format with optional time and zone
68     * @return
69     */
70   def parse(value: String, format: DateTimeFormatter = format): ZonedDateTime = {
71     import TemporalQueries._
72     format.parseBest(value, ZonedQuery, LocalQuery, LocalDateQuery, YearMonthQuery, YearQuery) match {
73       case d: ZonedDateTime => d
74       case d: LocalDateTime => d.atZone(ZoneOffset.UTC)
75       case d: LocalDate     => d.atTime(LocalTime.MIN).atZone(ZoneOffset.UTC)
76       case d: YearMonth     => d.atDay(1).atTime(LocalTime.MIN).atZone(ZoneOffset.UTC)
77       case d: Year          => d.atMonth(1).atDay(1).atTime(LocalTime.MIN).atZone(ZoneOffset.UTC)
78     }
79   }
80 
81   /**
82     * Parses a date string, with optional time and zone
83     *
84     * @param value date string
85     * @param format date formatter, default ISO format with optional time and zone
86     * @return
87     */
88   def parseInstant(value: String, format: DateTimeFormatter = format): Instant = {
89     import TemporalQueries.{LocalDateQuery, LocalQuery, ZonedQuery}
90     format.parseBest(value, ZonedQuery, LocalQuery, LocalDateQuery) match {
91       case d: ZonedDateTime => d.toInstant
92       case d: LocalDateTime => d.toInstant(ZoneOffset.UTC)
93       case d: LocalDate     => d.atTime(LocalTime.MIN).toInstant(ZoneOffset.UTC)
94     }
95   }
96 
97   /**
98     * Parses a date string, with optional time and zone
99     *
100     * @param value date string
101     * @param format date formatter, default ISO format with optional time and zone
102     * @return
103     */
104   def parseDate(value: String, format: DateTimeFormatter = format): Date = {
105     import TemporalQueries.{LocalDateQuery, LocalQuery, ZonedQuery}
106     format.parseBest(value, ZonedQuery, LocalQuery, LocalDateQuery) match {
107       case d: ZonedDateTime => Date.from(d.toInstant)
108       case d: LocalDateTime => Date.from(d.toInstant(ZoneOffset.UTC))
109       case d: LocalDate     => Date.from(d.atTime(LocalTime.MIN).toInstant(ZoneOffset.UTC))
110     }
111   }
112 
113   /**
114     * Parses a date string, with optional time and zone
115     *
116     * @param value date string
117     * @param format date formatter, default ISO format with optional time and zone
118     * @return
119     */
120   def parseMillis(value: String, format: DateTimeFormatter = format): Long = {
121     import TemporalQueries.{LocalDateQuery, LocalQuery, ZonedQuery}
122     format.parseBest(value, ZonedQuery, LocalQuery, LocalDateQuery) match {
123       case d: ZonedDateTime => d.toInstant.toEpochMilli
124       case d: LocalDateTime => d.toInstant(ZoneOffset.UTC).toEpochMilli
125       case d: LocalDate     => d.atTime(LocalTime.MIN).toInstant(ZoneOffset.UTC).toEpochMilli
126     }
127   }
128 
129   def format(value: ZonedDateTime, format: DateTimeFormatter = format): String = value.format(format)
130 
131   def formatDate(value: Date, format: DateTimeFormatter = format): String =
132     ZonedDateTime.ofInstant(toInstant(value), ZoneOffset.UTC).format(format)
133 
134   def formatInstant(value: Instant, format: DateTimeFormatter = format): String =
135     ZonedDateTime.ofInstant(value, ZoneOffset.UTC).format(format)
136 
137   def formatMillis(value: Long, format: DateTimeFormatter = format): String =
138     ZonedDateTime.ofInstant(Instant.ofEpochMilli(value), ZoneOffset.UTC).format(format)
139 }