kangaroo-and-rabbit/archidata
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

[FEAT] add some test for time system

Browse Source
This commit is contained in:
Edouard DUPIN 2025-04-06 23:24:58 +02:00
parent f044473a67
commit 16bb30b260
6 changed files with 422 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
test/src/test/kar/archidata/apiExtern/TestTime.java
View File

@ -20,6 +20,7 @@ import org.slf4j.LoggerFactory;
import test.kar.archidata.ConfigureDb;
import test.kar.archidata.StepwiseExtension;
import test.kar.archidata.apiExtern.model.DataForJSR310;
import test.kar.archidata.apiExtern.model.DataForJSR310String;
@ExtendWith(StepwiseExtension.class)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
@ -57,17 +58,113 @@ public class TestTime {
public void insertValue() throws Exception {
final DataForJSR310 data = new DataForJSR310();
data.time = LocalTime.now();
data.date = LocalDate.now();
data.dateTime = LocalDateTime.now();
data.localTime = LocalTime.now();
data.localDate = LocalDate.now();
data.localDateTime = LocalDateTime.now();
final DataForJSR310 inserted = api.post(DataForJSR310.class, TestTime.ENDPOINT_NAME, data);
Assertions.assertNotNull(inserted);
Assertions.assertNotNull(inserted.time);
Assertions.assertNotNull(inserted.date);
Assertions.assertNotNull(inserted.dateTime);
Assertions.assertEquals(inserted.time, data.time);
Assertions.assertEquals(inserted.date, data.date);
Assertions.assertEquals(inserted.dateTime, data.dateTime);
Assertions.assertNotNull(inserted.localTime);
Assertions.assertNotNull(inserted.localDate);
Assertions.assertNotNull(inserted.localDateTime);
Assertions.assertEquals(inserted.localTime, data.localTime);
Assertions.assertEquals(inserted.localDate, data.localDate);
Assertions.assertEquals(inserted.localDateTime, data.localDateTime);
}
@Order(2)
@Test
public void serializeValue() throws Exception {
String data = """
{
"date": "2025-04-04T15:15:07.123"
}
""";
String received = api.postJson(String.class, TestTime.ENDPOINT_NAME + "/serialize", data);
LOGGER.info("received: '{}'", received);
Assertions.assertEquals("Fri Apr 04 15:15:07 UTC 2025", received);
data = """
{
"date": "2025-04-04T15:15:07.123Z"
}
""";
received = api.postJson(String.class, TestTime.ENDPOINT_NAME + "/serialize", data);
LOGGER.info("received: '{}'", received);
Assertions.assertEquals("Fri Apr 04 15:15:07 UTC 2025", received);
data = """
{
"date": "2025-04-04T15:15:07.123+05:00"
}
""";
received = api.postJson(String.class, TestTime.ENDPOINT_NAME + "/serialize", data);
LOGGER.info("received: '{}'", received);
Assertions.assertEquals("Fri Apr 04 10:15:07 UTC 2025", received);
Assertions.assertNotNull(received);
}
@Order(3)
@Test
public void unserializeValue() throws Exception {
String data = "2025-04-04T15:15:07.123Z";
DataForJSR310String received = api.postJson(DataForJSR310String.class, TestTime.ENDPOINT_NAME + "/unserialize",
data);
LOGGER.info("send : '{}'", data);
LOGGER.info("received: '{}'", received.date);
LOGGER.info("----------------------------------------------------");
data = "2025-04-04T15:15:07.123";
received = api.postJson(DataForJSR310String.class, TestTime.ENDPOINT_NAME + "/unserialize", data);
LOGGER.info("send : '{}'", data);
LOGGER.info("received: '{}'", received.date);
LOGGER.info("----------------------------------------------------");
data = "2025-04-04T15:15:07.123+05:00";
received = api.postJson(DataForJSR310String.class, TestTime.ENDPOINT_NAME + "/unserialize", data);
LOGGER.info("send : '{}'", data);
LOGGER.info("received: '{}'", received.date);
LOGGER.info("----------------------------------------------------");
//Assertions.assertEquals("Fri Apr 04 15:15:07 UTC 2025", received);
}
@Order(50)
@Test
public void jakartaInputDate() throws Exception {
String data = "2025-04-04T15:15:07.123Z";
String received = api.get(String.class, TestTime.ENDPOINT_NAME + "/inputDate");
//String received = api.get(String.class, TestTime.ENDPOINT_NAME + "/inputDate?date=" + data);
LOGGER.info("send : '{}'", data);
LOGGER.info("received: '{}'", received);
LOGGER.info("----------------------------------------------------");
data = "2025-04-04T15:15:07.123";
received = api.get(String.class, TestTime.ENDPOINT_NAME + "/inputDate?date=" + data);
LOGGER.info("send : '{}'", data);
LOGGER.info("received: '{}'", received);
LOGGER.info("----------------------------------------------------");
data = "2025-04-04T15:15:07.123+05:00";
received = api.get(String.class, TestTime.ENDPOINT_NAME + "/inputDate?date=" + data);
LOGGER.info("send : '{}'", data);
LOGGER.info("received: '{}'", received);
LOGGER.info("----------------------------------------------------");
//Assertions.assertEquals("Fri Apr 04 15:15:07 UTC 2025", received);
}
@Order(51)
@Test
public void jakartaInputOffsetDateTime() throws Exception {
String data = "2025-04-04T15:15:07.123Z";
String received = api.get(String.class, TestTime.ENDPOINT_NAME + "/inputOffsetDateTime?date=" + data);
LOGGER.info("send : '{}'", data);
LOGGER.info("received: '{}'", received);
LOGGER.info("----------------------------------------------------");
data = "2025-04-04T15:15:07.123";
received = api.get(String.class, TestTime.ENDPOINT_NAME + "/inputOffsetDateTime?date=" + data);
LOGGER.info("send : '{}'", data);
LOGGER.info("received: '{}'", received);
LOGGER.info("----------------------------------------------------");
data = "2025-04-04T15:15:07.123+05:00";
received = api.get(String.class, TestTime.ENDPOINT_NAME + "/inputOffsetDateTime?date=" + data);
LOGGER.info("send : '{}'", data);
LOGGER.info("received: '{}'", received);
LOGGER.info("----------------------------------------------------");
//Assertions.assertEquals("Fri Apr 04 15:15:07 UTC 2025", received);
}
}

201
test/src/test/kar/archidata/apiExtern/TestTimeParsing.java Normal file
View File

@ -0,0 +1,201 @@
package test.kar.archidata.apiExtern;
import java.time.OffsetDateTime;
import java.util.Date;
import java.util.TimeZone;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.extension.ExtendWith;
import org.kar.archidata.tools.DateTools;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import test.kar.archidata.StepwiseExtension;
@ExtendWith(StepwiseExtension.class)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class TestTimeParsing {
private final static Logger LOGGER = LoggerFactory.getLogger(TestTime.class);
@BeforeAll
public static void setUp() {
// Set default timezone to UTC
//TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
}
// @Test
// public void testRaw() throws Exception {
// LOGGER.info("=======================================================================");
// String data = null;
// OffsetDateTime parsed = null;
// String manualFormat = null;
//
// data = "2025-04-04T15:15:07.123Z";
// //parsed = OffsetDateTime.parse(data, timeParserPerso);
// parsed = DateTools.parseOffsetDateTime(data);
// LOGGER.info(">> send : '{}'", data);
// LOGGER.info(">> parsed : '{}'", parsed);
// manualFormat = parsed.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'.'SSSX"));
// LOGGER.info(">> manualFormat: '{}'", manualFormat);
// manualFormat = parsed.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'.'nnnnnnnnnZ"));
// LOGGER.info(">> manualFormat: '{}'", manualFormat);
// LOGGER.info("----------------------------------------------------");
// data = "2025-04-04T15:15:07.123456789+05:00";
// //parsed = OffsetDateTime.parse(data, timeParserPerso);
// parsed = DateTools.parseOffsetDateTime(data);
// LOGGER.info(">> send : '{}'", data);
// LOGGER.info(">> parsed : '{}'", parsed);
// manualFormat = parsed.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'.'SSSX"));
// LOGGER.info(">> manualFormat: '{}'", manualFormat);
// manualFormat = parsed.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'.'nnnnnnnnnZ"));
// LOGGER.info(">> manualFormat: '{}'", manualFormat);
// LOGGER.info("----------------------------------------------------");
// data = "2025-04-04 15:15:07.123456789";
// //parsed = OffsetDateTime.parse(data, timeParserPersoUTC);
// parsed = DateTools.parseOffsetDateTime(data);
// LOGGER.info(">> send : '{}'", data);
// LOGGER.info(">> parsed : '{}'", parsed);
// manualFormat = parsed.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'.'SSSX"));
// LOGGER.info(">> manualFormat: '{}'", manualFormat);
// manualFormat = parsed.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'.'nnnnnnnnnZ"));
// LOGGER.info(">> manualFormat: '{}'", manualFormat);
// LOGGER.info("----------------------------------------------------");
// data = "2025-04-04 15:15:07";
// //parsed = OffsetDateTime.parse(data, timeParserPersoUTC);
// parsed = DateTools.parseOffsetDateTime(data);
// LOGGER.info(">> send : '{}'", data);
// LOGGER.info(">> parsed : '{}'", parsed);
// manualFormat = parsed.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'.'SSSX"));
// LOGGER.info(">> manualFormat: '{}'", manualFormat);
// manualFormat = parsed.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'.'nnnnnnnnnZ"));
// LOGGER.info(">> manualFormat: '{}'", manualFormat);
// LOGGER.info("----------------------------------------------------");
// data = "2025-04-04T15:15:07";
// //parsed = OffsetDateTime.parse(data, timeParserPersoUTC);
// parsed = DateTools.parseOffsetDateTime(data);
// LOGGER.info(">> send : '{}'", data);
// LOGGER.info(">> parsed : '{}'", parsed);
// manualFormat = parsed.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'.'SSSX"));
// LOGGER.info(">> manualFormat: '{}'", manualFormat);
// manualFormat = parsed.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'.'nnnnnnnnnZ"));
// LOGGER.info(">> manualFormat: '{}'", manualFormat);
// LOGGER.info("----------------------------------------------------");
//
// }
@Test
public void testDateRaw() throws Exception {
TimeZone.setDefault(TimeZone.getTimeZone("Asia/Tokyo"));
LOGGER.info("=======================================================================");
String data = null;
Date parsed = null;
data = "1999-01-30T18:16:17.123Z";
parsed = DateTools.parseDate(data);
Assertions.assertEquals("1999-01-31T03:16:17.123+09:00", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T18:16:17.123Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30T18:16:17.123456789Z";
parsed = DateTools.parseDate(data);
Assertions.assertEquals("1999-01-30T18:16:17.123000000Z", DateTools.serializeNanoWithUTCTimeZone(parsed));
data = "1999-01-30T18:16:17.123456789+05:00";
parsed = DateTools.parseDate(data);
Assertions.assertEquals("1999-01-30T22:16:17.123+09:00", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T13:16:17.123Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30T18:16:17.123456789";
parsed = DateTools.parseDate(data);
Assertions.assertEquals("1999-01-31T03:16:17.123+09:00", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T18:16:17.123Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30 18:16:17";
parsed = DateTools.parseDate(data);
Assertions.assertEquals("1999-01-31T03:16:17.000+09:00", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T18:16:17.000Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30T18:16:17";
parsed = DateTools.parseDate(data);
Assertions.assertEquals("1999-01-31T03:16:17.000+09:00", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T18:16:17.000Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30T18:16:17.123+09:00";
parsed = DateTools.parseDate(data);
Assertions.assertEquals("1999-01-30T18:16:17.123+09:00", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T09:16:17.123Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30T18:16:17.123+09";
parsed = DateTools.parseDate(data);
Assertions.assertEquals("1999-01-30T18:16:17.123+09:00", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T09:16:17.123Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30";
parsed = DateTools.parseDate(data);
Assertions.assertEquals("1999-01-30T09:00:00.000+09:00", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T00:00:00.000Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "18:16:17.123";
parsed = DateTools.parseDate(data);
Assertions.assertEquals("0001-01-02T03:35:16.123+09:18", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("0001-01-01T18:16:17.123Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
// data = "1999-01-30T18:16:17.123 UTC+09:00";
// parsed = DateTools.parseDate2(data);
// LOGGER.info(">> send : '{}'", data);
// LOGGER.info(">> format OTZ: '{}'", DateTools.serializeMilliWithOriginalTimeZone(parsed));
// LOGGER.info(">> format UTC: '{}'", DateTools.serializeMilliWithUTCTimeZone(parsed));
// LOGGER.info("----------------------------------------------------");
// Assertions.assertEquals("", DateTools.serializeMilliWithOriginalTimeZone(parsed));
// Assertions.assertEquals("", DateTools.serializeMilliWithUTCTimeZone(parsed));
}
@Test
public void testOffsetDateTime() throws Exception {
TimeZone.setDefault(TimeZone.getTimeZone("Asia/Tokyo"));
LOGGER.info("=======================================================================");
String data = null;
OffsetDateTime parsed = null;
data = "1999-01-30T18:16:17.123Z";
parsed = DateTools.parseOffsetDateTime(data);
Assertions.assertEquals("1999-01-30T18:16:17.123Z", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T18:16:17.123Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30T18:16:17.123456789Z";
parsed = DateTools.parseOffsetDateTime(data);
Assertions.assertEquals("1999-01-30T18:16:17.123456789Z", DateTools.serializeNanoWithUTCTimeZone(parsed));
data = "1999-01-30T18:16:17.123456789+05:00";
parsed = DateTools.parseOffsetDateTime(data);
Assertions.assertEquals("1999-01-30T18:16:17.123+05:00", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T13:16:17.123Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30T18:16:17.123456789";
parsed = DateTools.parseOffsetDateTime(data);
Assertions.assertEquals("1999-01-30T18:16:17.123Z", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T18:16:17.123Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30 18:16:17";
parsed = DateTools.parseOffsetDateTime(data);
Assertions.assertEquals("1999-01-30T18:16:17.000Z", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T18:16:17.000Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30T18:16:17";
parsed = DateTools.parseOffsetDateTime(data);
Assertions.assertEquals("1999-01-30T18:16:17.000Z", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T18:16:17.000Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30T18:16:17.123+09:00";
parsed = DateTools.parseOffsetDateTime(data);
Assertions.assertEquals("1999-01-30T18:16:17.123+09:00", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T09:16:17.123Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30T18:16:17.123+09";
parsed = DateTools.parseOffsetDateTime(data);
Assertions.assertEquals("1999-01-30T18:16:17.123+09:00", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T09:16:17.123Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "1999-01-30";
parsed = DateTools.parseOffsetDateTime(data);
Assertions.assertEquals("1999-01-30T00:00:00.000Z", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("1999-01-30T00:00:00.000Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
data = "18:16:17.123";
parsed = DateTools.parseOffsetDateTime(data);
Assertions.assertEquals("0001-01-01T18:16:17.123Z", DateTools.serializeMilliWithOriginalTimeZone(parsed));
Assertions.assertEquals("0001-01-01T18:16:17.123Z", DateTools.serializeMilliWithUTCTimeZone(parsed));
// data = "1999-01-30T18:16:17.123 UTC+09:00";
// parsed = DateTools.parseDate2(data);
// LOGGER.info(">> send : '{}'", data);
// LOGGER.info(">> format OTZ: '{}'", DateTools.serializeMilliWithOriginalTimeZone(parsed));
// LOGGER.info(">> format UTC: '{}'", DateTools.serializeMilliWithUTCTimeZone(parsed));
// LOGGER.info("----------------------------------------------------");
// Assertions.assertEquals("", DateTools.serializeMilliWithOriginalTimeZone(parsed));
// Assertions.assertEquals("", DateTools.serializeMilliWithUTCTimeZone(parsed));
}
}

12
test/src/test/kar/archidata/apiExtern/WebLauncher.java
View File

@ -2,6 +2,7 @@ package test.kar.archidata.apiExtern;
import java.net.URI;
import java.util.Iterator;
import java.util.TimeZone;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
@ -16,6 +17,8 @@ import org.kar.archidata.UpdateJwtPublicKey;
import org.kar.archidata.api.DataResource;
import org.kar.archidata.api.ProxyResource;
import org.kar.archidata.catcher.GenericCatcher;
import org.kar.archidata.converter.Jakarta.DateParamConverter;
import org.kar.archidata.converter.Jakarta.OffsetDateTimeParamConverter;
import org.kar.archidata.db.DbConfig;
import org.kar.archidata.exception.DataAccessException;
import org.kar.archidata.filter.CORSFilter;
@ -35,7 +38,10 @@ public class WebLauncher {
protected UpdateJwtPublicKey keyUpdater = null;
protected HttpServer server = null;
public WebLauncher() {}
public WebLauncher() {
// Set default timezone to UTC
TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
}
private static URI getBaseURI() {
return UriBuilder.fromUri(ConfigBaseVariable.getlocalAddress()).build();
@ -99,6 +105,10 @@ public class WebLauncher {
// ===================================================================
final ResourceConfig rc = new ResourceConfig();
// Add permissive date converter for jakarta
rc.register(DateParamConverter.class);
rc.register(OffsetDateTimeParamConverter.class);
// add multipart models ..
rc.register(MultiPartFeature.class);
// global authentication system

17
test/src/test/kar/archidata/apiExtern/model/DataForJSR310.java
View File

@ -3,15 +3,22 @@ package test.kar.archidata.apiExtern.model;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZonedDateTime;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonInclude;
@JsonInclude(JsonInclude.Include.NON_NULL)
public class DataForJSR310 {
public LocalTime time;
public LocalDate date;
public LocalDateTime dateTime;
public LocalTime localTime;
public LocalDate localDate;
public Date date;
public LocalDateTime localDateTime;
public ZonedDateTime zoneDateTime;
@Override
public String toString() {
return "DataForJSR310 [time=" + this.time + ", date=" + this.date + ", dateTime=" + this.dateTime + "]";
return "DataForJSR310 [localTime=" + this.localTime + ", localDate=" + this.localDate + ", localDateTime="
+ this.localDateTime + ", zoneDateTime=" + this.zoneDateTime + "]";
}
}

18
test/src/test/kar/archidata/apiExtern/model/DataForJSR310String.java Normal file
View File

@ -0,0 +1,18 @@
package test.kar.archidata.apiExtern.model;
import com.fasterxml.jackson.annotation.JsonInclude;
@JsonInclude(JsonInclude.Include.NON_NULL)
public class DataForJSR310String {
public String localTime;
public String localDate;
public String date;
public String localDateTime;
public String zoneDateTime;
@Override
public String toString() {
return "DataForJSR310 [localTime=" + this.localTime + ", localDate=" + this.localDate + ", localDateTime="
+ this.localDateTime + ", zoneDateTime=" + this.zoneDateTime + "]";
}
}

74
test/src/test/kar/archidata/apiExtern/resource/TimeResource.java
View File

@ -1,12 +1,22 @@
package test.kar.archidata.apiExtern.resource;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.ZonedDateTime;
import java.util.Date;
import org.kar.archidata.tools.DateTools;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jakarta.annotation.security.PermitAll;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.QueryParam;
import jakarta.ws.rs.core.MediaType;
import test.kar.archidata.apiExtern.model.DataForJSR310;
@ -22,4 +32,68 @@ public class TimeResource {
return data;
}
@POST
@Path("serialize")
@PermitAll
public String serialize(final DataForJSR310 data) throws Exception {
LOGGER.warn("receive Data: {}", data);
if (data.localDate != null) {
return data.localDate.toString();
}
if (data.localDateTime != null) {
return data.localDateTime.toString();
}
if (data.localTime != null) {
return data.localTime.toString();
}
if (data.zoneDateTime != null) {
return data.zoneDateTime.toString();
}
if (data.date != null) {
return data.date.toString();
}
return "";
}
@POST
@Path("unserialize")
@PermitAll
public DataForJSR310 unserialize(final String data) throws Exception {
LOGGER.warn("receive Data: {}", data);
final DataForJSR310 newData = new DataForJSR310();
try {
newData.localDate = LocalDate.parse(data);
} catch (final Exception ex) {}
try {
newData.localDateTime = LocalDateTime.parse(data);
} catch (final Exception ex) {}
try {
newData.date = DateTools.parseDate(data);
// final DateTimeFormatter formatter = DateTimeFormatter.ISO_OFFSET_DATE_TIME;
// final OffsetDateTime dateTime = OffsetDateTime.parse(data, formatter);
// final Instant instant = dateTime.toInstant();
// newData.date = Date.from(instant);
} catch (final Exception ex) {}
try {
newData.localTime = LocalTime.parse(data);
} catch (final Exception ex) {}
try {
newData.zoneDateTime = ZonedDateTime.parse(data);
} catch (final Exception ex) {}
return newData;
}
@GET
@PermitAll
@Path("inputDate")
public String postInputDate(@QueryParam("date") final Date data) throws Exception {
return DateTools.serializeNanoWithUTCTimeZone(data);
}
@GET
@PermitAll
@Path("inputOffsetDateTime")
public String postInputOffsetDateTime(@QueryParam("date") final OffsetDateTime data) throws Exception {
return DateTools.serializeNanoWithUTCTimeZone(data);
}
}