Causeway 3989

api/applib/pom.xml

@@ -107,6 +107,18 @@
 			<scope>test</scope>
 		</dependency>
 
+        <dependency>
+            <groupId>com.approvaltests</groupId>
+            <artifactId>approvaltests</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <!-- required by com.approvaltests:test (version managed by spring boot) -->
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <scope>test</scope>
+        </dependency>
+
     </dependencies>
 
 </project>

api/applib/src/main/java/module-info.java

@@ -146,6 +146,7 @@
     requires transitive spring.core;
     requires spring.tx;
     requires org.apache.logging.log4j.core;
+	requires com.fasterxml.jackson.annotation;
 
     // JAXB viewmodels
     opens org.apache.causeway.applib.annotation;

api/applib/src/main/java/org/apache/causeway/applib/util/schema/CommandDtoUtils.java

@@ -18,17 +18,47 @@
  */
 package org.apache.causeway.applib.util.schema;
 
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import javax.xml.datatype.DatatypeConstants;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+
 import org.apache.causeway.applib.services.bookmark.Bookmark;
 import org.apache.causeway.commons.internal.base._Lazy;
+import org.apache.causeway.commons.internal.base._NullSafe;
 import org.apache.causeway.commons.internal.base._Strings;
+import org.apache.causeway.commons.io.DataSource;
 import org.apache.causeway.commons.io.DtoMapper;
 import org.apache.causeway.commons.io.JaxbUtils;
+import org.apache.causeway.commons.io.JsonUtils;
+import org.apache.causeway.commons.io.JsonUtils.JacksonCustomizer;
+import org.apache.causeway.commons.io.YamlUtils;
 import org.apache.causeway.schema.cmd.v2.ActionDto;
 import org.apache.causeway.schema.cmd.v2.CommandDto;
 import org.apache.causeway.schema.cmd.v2.MapDto;
+import org.apache.causeway.schema.cmd.v2.MemberDto;
 import org.apache.causeway.schema.cmd.v2.ParamsDto;
+import org.apache.causeway.schema.cmd.v2.PropertyDto;
 import org.apache.causeway.schema.common.v2.OidsDto;
 import org.apache.causeway.schema.common.v2.PeriodDto;
+import org.apache.causeway.schema.common.v2.ValueDto;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.fasterxml.jackson.databind.jsontype.NamedType;
 
 import lombok.experimental.UtilityClass;
 
@@ -117,4 +147,230 @@ private MapDto userDataFor(final CommandDto commandDto) {
         return userData;
     }
 
+    // -- YAML SUPPORT
+
+    public String toYaml(final Iterable<CommandDto> commandDtos) {
+    	final JsonUtils.JacksonCustomizer customizer = new JacksonCustomizer() {
+			@Override
+			public ObjectMapper apply(ObjectMapper mapper) {
+				JsonUtils.jaxbAnnotationSupport(mapper);
+				CommandDtoUtils.memberDtoSupport(mapper);
+				CommandDtoUtils.valueDtoSupport(mapper);
+				JsonUtils.onlyIncludeNonNull(mapper);
+				return mapper;
+			}
+		};
+        return YamlUtils.toStringUtf8(
+            _NullSafe.stream(commandDtos)
+                .collect(Collectors.toList()),
+            customizer);
+    }
+
+    public List<CommandDto> fromYaml(final DataSource commandDtosYaml) {
+    	final JsonUtils.JacksonCustomizer customizer = new JacksonCustomizer() {
+			@Override
+			public ObjectMapper apply(ObjectMapper mapper) {
+				JsonUtils.jaxbAnnotationSupport(mapper);
+				CommandDtoUtils.memberDtoSupport(mapper);
+				CommandDtoUtils.valueDtoSupport(mapper);
+				return mapper;
+			}
+		};
+        return YamlUtils.tryReadAsList(CommandDto.class, commandDtosYaml, customizer)
+            .ifFailureFail()
+            .getValue()
+            .orElseGet(Collections::emptyList);
+    }
+
+    // Mix-in to add type metadata to MemberDto
+    @JsonTypeInfo(
+            use = JsonTypeInfo.Id.NAME,
+            include = JsonTypeInfo.As.PROPERTY,
+            property = "type")
+    private abstract class AbstractDtoMixIn {}
+
+    // Mix-in to ignore unknown properties for ValueDto
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    private abstract class AbstractValueDtoMixIn {
+        @JsonSerialize(using = LocalDateXmlGregorianCalendarSerializer.class)
+        abstract XMLGregorianCalendar getLocalDate();
+
+        @JsonDeserialize(using = LocalDateXmlGregorianCalendarDeserializer.class)
+        abstract void setLocalDate(XMLGregorianCalendar localDate);
+
+        @JsonSerialize(using = LocalDateTimeXmlGregorianCalendarSerializer.class)
+        abstract XMLGregorianCalendar getLocalDateTime();
+
+        @JsonDeserialize(using = LocalDateTimeXmlGregorianCalendarDeserializer.class)
+        abstract void setLocalDateTime(XMLGregorianCalendar localDateTime);
+
+        @JsonSerialize(using = LocalTimeXmlGregorianCalendarSerializer.class)
+        abstract XMLGregorianCalendar getLocalTime();
+
+        @JsonDeserialize(using = LocalTimeXmlGregorianCalendarDeserializer.class)
+        abstract void setLocalTime(XMLGregorianCalendar localTime);
+    }
+
+    private void valueDtoSupport(final ObjectMapper mb) {
+        mb.addMixIn(ValueDto.class, AbstractValueDtoMixIn.class);
+    }
+
+    private static final DatatypeFactory DATATYPE_FACTORY = datatypeFactory();
+
+    private static DatatypeFactory datatypeFactory() {
+        try {
+            return DatatypeFactory.newInstance();
+        } catch (Exception ex) {
+            throw new RuntimeException("Failed to initialize DatatypeFactory", ex);
+        }
+    }
+
+    private static final class LocalDateXmlGregorianCalendarSerializer
+            extends JsonSerializer<XMLGregorianCalendar> {
+
+        @Override
+        public void serialize(
+                final XMLGregorianCalendar value,
+                final JsonGenerator gen,
+                final SerializerProvider serializers) throws IOException {
+            if (value == null) {
+                gen.writeNull();
+                return;
+            }
+            final XMLGregorianCalendar dateOnly = DATATYPE_FACTORY.newXMLGregorianCalendarDate(
+                    value.getYear(),
+                    value.getMonth(),
+                    value.getDay(),
+                    DatatypeConstants.FIELD_UNDEFINED);
+            gen.writeString(dateOnly.toXMLFormat());
+        }
+    }
+
+    private static final class LocalDateXmlGregorianCalendarDeserializer
+            extends JsonDeserializer<XMLGregorianCalendar> {
+
+        @Override
+        public XMLGregorianCalendar deserialize(
+                final JsonParser p,
+                final DeserializationContext ctxt) throws IOException {
+            final String text = p.getValueAsString();
+            if (_Strings.isNullOrEmpty(text)) {
+                return null;
+            }
+            final XMLGregorianCalendar parsed = DATATYPE_FACTORY.newXMLGregorianCalendar(text);
+            return DATATYPE_FACTORY.newXMLGregorianCalendarDate(
+                    parsed.getYear(),
+                    parsed.getMonth(),
+                    parsed.getDay(),
+                    DatatypeConstants.FIELD_UNDEFINED);
+        }
+    }
+
+    private static final class LocalDateTimeXmlGregorianCalendarSerializer
+            extends JsonSerializer<XMLGregorianCalendar> {
+
+        @Override
+        public void serialize(
+                final XMLGregorianCalendar value,
+                final JsonGenerator gen,
+                final SerializerProvider serializers) throws IOException {
+            if (value == null) {
+                gen.writeNull();
+                return;
+            }
+            final XMLGregorianCalendar localDateTime = DATATYPE_FACTORY.newXMLGregorianCalendar(
+                    value.getYear(),
+                    value.getMonth(),
+                    value.getDay(),
+                    value.getHour(),
+                    value.getMinute(),
+                    value.getSecond(),
+                    millisecondsOf(value),
+                    DatatypeConstants.FIELD_UNDEFINED);
+            gen.writeString(localDateTime.toXMLFormat());
+        }
+    }
+
+    private static final class LocalDateTimeXmlGregorianCalendarDeserializer
+            extends JsonDeserializer<XMLGregorianCalendar> {
+
+        @Override
+        public XMLGregorianCalendar deserialize(
+                final JsonParser p,
+                final DeserializationContext ctxt) throws IOException {
+            final String text = p.getValueAsString();
+            if (_Strings.isNullOrEmpty(text)) {
+                return null;
+            }
+            final XMLGregorianCalendar parsed = DATATYPE_FACTORY.newXMLGregorianCalendar(text);
+            return DATATYPE_FACTORY.newXMLGregorianCalendar(
+                    parsed.getYear(),
+                    parsed.getMonth(),
+                    parsed.getDay(),
+                    parsed.getHour(),
+                    parsed.getMinute(),
+                    parsed.getSecond(),
+                    millisecondsOf(parsed),
+                    DatatypeConstants.FIELD_UNDEFINED);
+        }
+    }
+
+    private static final class LocalTimeXmlGregorianCalendarSerializer
+            extends JsonSerializer<XMLGregorianCalendar> {
+
+        @Override
+        public void serialize(
+                final XMLGregorianCalendar value,
+                final JsonGenerator gen,
+                final SerializerProvider serializers) throws IOException {
+            if (value == null) {
+                gen.writeNull();
+                return;
+            }
+            final XMLGregorianCalendar localTime = DATATYPE_FACTORY.newXMLGregorianCalendarTime(
+                    value.getHour(),
+                    value.getMinute(),
+                    value.getSecond(),
+                    millisecondsOf(value),
+                    DatatypeConstants.FIELD_UNDEFINED);
+            gen.writeString(localTime.toXMLFormat());
+        }
+    }
+
+    private static final class LocalTimeXmlGregorianCalendarDeserializer
+            extends JsonDeserializer<XMLGregorianCalendar> {
+
+        @Override
+        public XMLGregorianCalendar deserialize(
+                final JsonParser p,
+                final DeserializationContext ctxt) throws IOException {
+            final String text = p.getValueAsString();
+            if (_Strings.isNullOrEmpty(text)) {
+                return null;
+            }
+            final XMLGregorianCalendar parsed = DATATYPE_FACTORY.newXMLGregorianCalendar(text);
+            return DATATYPE_FACTORY.newXMLGregorianCalendarTime(
+                    parsed.getHour(),
+                    parsed.getMinute(),
+                    parsed.getSecond(),
+                    millisecondsOf(parsed),
+                    DatatypeConstants.FIELD_UNDEFINED);
+        }
+    }
+
+    private static int millisecondsOf(final XMLGregorianCalendar value) {
+        final int millis = value.getMillisecond();
+        return millis == DatatypeConstants.FIELD_UNDEFINED
+                ? DatatypeConstants.FIELD_UNDEFINED
+                : millis;
+    }
+
+    private void memberDtoSupport(final ObjectMapper mb) {
+        // add mix-in so MemberDto carries @JsonTypeInfo without modifying source
+        mb.addMixIn(MemberDto.class, AbstractDtoMixIn.class);
+        // register concrete sub-types with logical names
+        mb.registerSubtypes(new NamedType(ActionDto.class, "ACT"));
+        mb.registerSubtypes(new NamedType(PropertyDto.class, "PROP"));
+    }
+
 }

api/applib/src/test/java/org/apache/causeway/applib/util/schema/CommandDtoUtils_Test.java

@@ -18,6 +18,13 @@
  */
 package org.apache.causeway.applib.util.schema;
 
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.apache.causeway.applib.value.Blob;
+import org.apache.causeway.applib.value.NamedWithMimeType;
+
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -28,6 +35,8 @@
 import org.apache.causeway.schema.cmd.v2.CommandDto;
 import org.apache.causeway.schema.cmd.v2.MapDto;
 
+import org.springframework.util.StreamUtils;
+
 public class CommandDtoUtils_Test {
 
     CommandDto dto;
@@ -76,4 +85,5 @@ public void clearUserData() {
         // then
         assertThat(CommandDtoUtils.getUserData(dto, "someKey"), is(nullValue()));
     }
+
 }